Attachment #464608 for bug #222366

View Details Raw Unified Return to Bug 222366

| Differences between

Lines 183-188 set(WebKitGTK_HEADER_TEMPLATES a/Source/WebKit/PlatformGTK.cmake_sec1
- a/Source/WebKit/PlatformGTK.cmake +6 lines
183	${WEBKIT_DIR}/UIProcess/API/gtk/WebKitWebViewBase.h.in	183	${WEBKIT_DIR}/UIProcess/API/gtk/WebKitWebViewBase.h.in
184	)	184	)
185		185
		186	if (ENABLE_2022_GLIB_API)
		187	list(APPEND WebKitGTK_HEADER_TEMPLATES
		188	${WEBKIT_DIR}/UIProcess/API/glib/WebKitNetworkSession.h.in
		189	)
		190	endif ()
		191
186	set(WebKitGTK_INSTALLED_HEADERS	192	set(WebKitGTK_INSTALLED_HEADERS
187	${WebKitGTK_DERIVED_SOURCES_DIR}/webkit/WebKitEnumTypes.h	193	${WebKitGTK_DERIVED_SOURCES_DIR}/webkit/WebKitEnumTypes.h
188	${WebKitGTK_DERIVED_SOURCES_DIR}/webkit/WebKitVersion.h	194	${WebKitGTK_DERIVED_SOURCES_DIR}/webkit/WebKitVersion.h

Lines 157-162 UIProcess/API/glib/WebKitNavigationAction.cpp @no-unify a/Source/WebKit/SourcesGTK.txt_sec1
- a/Source/WebKit/SourcesGTK.txt +1 lines
157	UIProcess/API/glib/WebKitNavigationClient.cpp @no-unify	157	UIProcess/API/glib/WebKitNavigationClient.cpp @no-unify
158	UIProcess/API/glib/WebKitNavigationPolicyDecision.cpp @no-unify	158	UIProcess/API/glib/WebKitNavigationPolicyDecision.cpp @no-unify
159	UIProcess/API/glib/WebKitNetworkProxySettings.cpp @no-unify	159	UIProcess/API/glib/WebKitNetworkProxySettings.cpp @no-unify
		160	UIProcess/API/glib/WebKitNetworkSession.cpp @no-unify
160	UIProcess/API/glib/WebKitNotification.cpp @no-unify	161	UIProcess/API/glib/WebKitNotification.cpp @no-unify
161	UIProcess/API/glib/WebKitNotificationPermissionRequest.cpp @no-unify	162	UIProcess/API/glib/WebKitNotificationPermissionRequest.cpp @no-unify
162	UIProcess/API/glib/WebKitNotificationProvider.cpp @no-unify	163	UIProcess/API/glib/WebKitNotificationProvider.cpp @no-unify

Lines 56-62 IconDatabase::IconDatabase(const String& path, AllowDatabaseWrite allowDatabaseW a/Source/WebKit/UIProcess/API/glib/IconDatabase.cpp_sec1
- a/Source/WebKit/UIProcess/API/glib/IconDatabase.cpp -1 / +1 lines
56	// We initialize the database synchronously, it's hopefully fast enough because it makes	56	// We initialize the database synchronously, it's hopefully fast enough because it makes
57	// the implementation a lot simpler.	57	// the implementation a lot simpler.
58	m_workQueue->dispatchSync([&] {	58	m_workQueue->dispatchSync([&] {
59	if (allowDatabaseWrite == AllowDatabaseWrite::No && !FileSystem::fileExists(path))	59	if (allowDatabaseWrite == AllowDatabaseWrite::No && (!path.isNull() \|\| !FileSystem::fileExists(path)))
60	return;	60	return;
61		61
62	auto databaseDirectory = FileSystem::parentPath(path);	62	auto databaseDirectory = FileSystem::parentPath(path);

Lines 45-50 G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitInputMethodContext, g_object_unref) a/Source/WebKit/UIProcess/API/glib/WebKitAutocleanups.h.in_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitAutocleanups.h.in +3 lines
45	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitInstallMissingMediaPluginsPermissionRequest, g_object_unref)	45	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitInstallMissingMediaPluginsPermissionRequest, g_object_unref)
46	#endif	46	#endif
47	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNavigationPolicyDecision, g_object_unref)	47	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNavigationPolicyDecision, g_object_unref)
		48	#if ENABLE(2022_GLIB_API)
		49	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNetworkSession, g_object_unref)
		50	#endif
48	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNotification, g_object_unref)	51	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNotification, g_object_unref)
49	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNotificationPermissionRequest, g_object_unref)	52	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNotificationPermissionRequest, g_object_unref)
50	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitPermissionRequest, g_object_unref)	53	G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitPermissionRequest, g_object_unref)

Lines 31-36 a/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp -2 / +28 lines
31	#include <wtf/glib/WTFGType.h>	31	#include <wtf/glib/WTFGType.h>
32	#include <wtf/text/CString.h>	32	#include <wtf/text/CString.h>
33		33
		34	#if ENABLE(2022_GLIB_API)
		35	#include "WebKitNetworkSession.h"
		36	#endif
		37
34	using namespace WebKit;	38	using namespace WebKit;
35		39
36	/**	40	/**
Lines 350-362 WebKitAutomationSession* webkitAutomationSessionCreate(WebKitWebContext* webCont a/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp_sec2
350	{	354	{
351	auto* session = WEBKIT_AUTOMATION_SESSION(g_object_new(WEBKIT_TYPE_AUTOMATION_SESSION, "id", sessionID, nullptr));	355	auto* session = WEBKIT_AUTOMATION_SESSION(g_object_new(WEBKIT_TYPE_AUTOMATION_SESSION, "id", sessionID, nullptr));
352	session->priv->webContext = webContext;	356	session->priv->webContext = webContext;
353	if (capabilities.acceptInsecureCertificates)	357	#if ENABLE(2022_GLIB_API)
		358	WebKitNetworkSession* networkSession = webkitWebContextGetNetworkSessionForAutomation(webContext);
		359	#endif
		360
		361	if (capabilities.acceptInsecureCertificates) {
		362	#if ENABLE(2022_GLIB_API)
		363	webkit_network_session_set_tls_errors_policy(networkSession, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		364	#else
354	webkit_website_data_manager_set_tls_errors_policy(webkit_web_context_get_website_data_manager(webContext), WEBKIT_TLS_ERRORS_POLICY_IGNORE);	365	webkit_website_data_manager_set_tls_errors_policy(webkit_web_context_get_website_data_manager(webContext), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		366	#endif
		367	}
355		368
356	for (auto& certificate : capabilities.certificates) {	369	for (auto& certificate : capabilities.certificates) {
357	GRefPtr<GTlsCertificate> tlsCertificate = adoptGRef(g_tls_certificate_new_from_file(certificate.second.utf8().data(), nullptr));	370	GRefPtr<GTlsCertificate> tlsCertificate = adoptGRef(g_tls_certificate_new_from_file(certificate.second.utf8().data(), nullptr));
358	if (tlsCertificate)	371	if (tlsCertificate) {
		372	#if ENABLE(2022_GLIB_API)
		373	webkit_network_session_allow_tls_certificate_for_host(networkSession, tlsCertificate.get(), certificate.first.utf8().data());
		374	#else
359	webkit_web_context_allow_tls_certificate_for_host(webContext, tlsCertificate.get(), certificate.first.utf8().data());	375	webkit_web_context_allow_tls_certificate_for_host(webContext, tlsCertificate.get(), certificate.first.utf8().data());
		376	#endif
		377	}
360	}	378	}
361	if (capabilities.proxy) {	379	if (capabilities.proxy) {
362	if (capabilities.proxy->type == "pac"_s) {	380	if (capabilities.proxy->type == "pac"_s) {
Lines 365-377 WebKitAutomationSession* webkitAutomationSessionCreate(WebKitWebContext* webCont a/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp_sec3
365	if (capabilities.proxy->autoconfigURL)	383	if (capabilities.proxy->autoconfigURL)
366	settings.defaultProxyURL = capabilities.proxy->autoconfigURL->utf8();	384	settings.defaultProxyURL = capabilities.proxy->autoconfigURL->utf8();
367	if (!settings.isEmpty()) {	385	if (!settings.isEmpty()) {
		386	#if ENABLE(2022_GLIB_API)
		387	auto& dataStore = webkitWebsiteDataManagerGetDataStore(webkit_network_session_get_website_data_manager(networkSession));
		388	#else
368	auto& dataStore = webkitWebsiteDataManagerGetDataStore(webkit_web_context_get_website_data_manager(webContext));	389	auto& dataStore = webkitWebsiteDataManagerGetDataStore(webkit_web_context_get_website_data_manager(webContext));
		390	#endif
369	dataStore.setNetworkProxySettings(WTFMove(settings));	391	dataStore.setNetworkProxySettings(WTFMove(settings));
370	}	392	}
371	} else {	393	} else {
372	WebKitNetworkProxySettings* proxySettings = nullptr;	394	WebKitNetworkProxySettings* proxySettings = nullptr;
373	auto proxyMode = parseProxyCapabilities(*capabilities.proxy, &proxySettings);	395	auto proxyMode = parseProxyCapabilities(*capabilities.proxy, &proxySettings);
		396	#if ENABLE(2022_GLIB_API)
		397	webkit_network_session_set_proxy_settings(networkSession, proxyMode, proxySettings);
		398	#else
374	webkit_website_data_manager_set_network_proxy_settings(webkit_web_context_get_website_data_manager(webContext), proxyMode, proxySettings);	399	webkit_website_data_manager_set_network_proxy_settings(webkit_web_context_get_website_data_manager(webContext), proxyMode, proxySettings);
		400	#endif
375	if (proxySettings)	401	if (proxySettings)
376	webkit_network_proxy_settings_free(proxySettings);	402	webkit_network_proxy_settings_free(proxySettings);
377	}	403	}

Lines 34-39 a/Source/WebKit/UIProcess/API/glib/WebKitNavigationClient.cpp_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitNavigationClient.cpp +16 lines
34	#include <wtf/glib/GUniquePtr.h>	34	#include <wtf/glib/GUniquePtr.h>
35	#include <wtf/text/CString.h>	35	#include <wtf/text/CString.h>
36		36
		37	#if ENABLE(2022_GLIB_API)
		38	#include "WebKitNetworkSessionPrivate.h"
		39	#endif
		40
37	using namespace WebKit;	41	using namespace WebKit;
38	using namespace WebCore;	42	using namespace WebCore;
39		43
Lines 158-176 private: a/Source/WebKit/UIProcess/API/glib/WebKitNavigationClient.cpp_sec2
158	void navigationActionDidBecomeDownload(WebPageProxy&, API::NavigationAction&, DownloadProxy& downloadProxy) override	162	void navigationActionDidBecomeDownload(WebPageProxy&, API::NavigationAction&, DownloadProxy& downloadProxy) override
159	{	163	{
160	auto download = webkitDownloadCreate(downloadProxy, m_webView);	164	auto download = webkitDownloadCreate(downloadProxy, m_webView);
		165	#if ENABLE(2022_GLIB_API)
		166	webkitNetworkSessionDownloadStarted(webkit_web_view_get_network_session(m_webView), download.get());
		167	#else
161	webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());	168	webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());
		169	#endif
162	}	170	}
163		171
164	void navigationResponseDidBecomeDownload(WebPageProxy&, API::NavigationResponse&, DownloadProxy& downloadProxy) override	172	void navigationResponseDidBecomeDownload(WebPageProxy&, API::NavigationResponse&, DownloadProxy& downloadProxy) override
165	{	173	{
166	auto download = webkitDownloadCreate(downloadProxy, m_webView);	174	auto download = webkitDownloadCreate(downloadProxy, m_webView);
		175	#if ENABLE(2022_GLIB_API)
		176	webkitNetworkSessionDownloadStarted(webkit_web_view_get_network_session(m_webView), download.get());
		177	#else
167	webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());	178	webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());
		179	#endif
168	}	180	}
169		181
170	void contextMenuDidCreateDownload(WebPageProxy&, DownloadProxy& downloadProxy) override	182	void contextMenuDidCreateDownload(WebPageProxy&, DownloadProxy& downloadProxy) override
171	{	183	{
172	auto download = webkitDownloadCreate(downloadProxy, m_webView);	184	auto download = webkitDownloadCreate(downloadProxy, m_webView);
		185	#if ENABLE(2022_GLIB_API)
		186	webkitNetworkSessionDownloadStarted(webkit_web_view_get_network_session(m_webView), download.get());
		187	#else
173	webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());	188	webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());
		189	#endif
174	}	190	}
175		191
176	WebKitWebView* m_webView;	192	WebKitWebView* m_webView;



/*
 * 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);
}

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 #WebKitITPThirdParty<!-- -->s 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)



/*
 * 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



/*
 * 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*);

Lines 80-85 a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp -10 / +58 lines
80	#include "WebKitRemoteInspectorProtocolHandler.h"	80	#include "WebKitRemoteInspectorProtocolHandler.h"
81	#endif	81	#endif
82		82
		83	#if ENABLE(2022_GLIB_API)
		84	#include "WebKitNetworkSession.h"
		85	#endif
		86
83	using namespace WebKit;	87	using namespace WebKit;
84		88
85	/**	89	/**
Lines 118-124 enum { a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec2
118	#if PLATFORM(GTK) && !USE(GTK4)	122	#if PLATFORM(GTK) && !USE(GTK4)
119	PROP_LOCAL_STORAGE_DIRECTORY,	123	PROP_LOCAL_STORAGE_DIRECTORY,
120	#endif	124	#endif
		125	#if !ENABLE(2022_GLIB_API)
121	PROP_WEBSITE_DATA_MANAGER,	126	PROP_WEBSITE_DATA_MANAGER,
		127	#endif
122	#if PLATFORM(GTK) && !USE(GTK4)	128	#if PLATFORM(GTK) && !USE(GTK4)
123	PROP_PSON_ENABLED,	129	PROP_PSON_ENABLED,
124	PROP_USE_SYSTEM_APPEARANCE_FOR_SCROLLBARS,	130	PROP_USE_SYSTEM_APPEARANCE_FOR_SCROLLBARS,
Lines 131-137 enum { a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec3
131	static GParamSpec* sObjProperties[N_PROPERTIES] = { nullptr, };	137	static GParamSpec* sObjProperties[N_PROPERTIES] = { nullptr, };
132		138
133	enum {	139	enum {
		140	#if !ENABLE(2022_GLIB_API)
134	DOWNLOAD_STARTED,	141	DOWNLOAD_STARTED,
		142	#endif
135	INITIALIZE_WEB_EXTENSIONS,	143	INITIALIZE_WEB_EXTENSIONS,
136	INITIALIZE_NOTIFICATION_PERMISSIONS,	144	INITIALIZE_NOTIFICATION_PERMISSIONS,
137	AUTOMATION_STARTED,	145	AUTOMATION_STARTED,
Lines 200-209 typedef HashMap<String, RefPtr<WebKitURISchemeHandler> > URISchemeHandlerMap; a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec4
200	class WebKitAutomationClient;	208	class WebKitAutomationClient;
201		209
202	struct _WebKitWebContextPrivate {	210	struct _WebKitWebContextPrivate {
		211	#if !ENABLE(2022_GLIB_API)
203	_WebKitWebContextPrivate()	212	_WebKitWebContextPrivate()
204	: dnsPrefetchHystereris([this](PAL::HysteresisState state) { if (state == PAL::HysteresisState::Stopped) dnsPrefetchedHosts.clear(); })	213	: dnsPrefetchHystereris([this](PAL::HysteresisState state) { if (state == PAL::HysteresisState::Stopped) dnsPrefetchedHosts.clear(); })
205	{	214	{
206	}	215	}
		216	#endif
207		217
208	RefPtr<WebProcessPool> processPool;	218	RefPtr<WebProcessPool> processPool;
209	bool clientsDetached;	219	bool clientsDetached;
Lines 212-225 struct _WebKitWebContextPrivate { a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec5
212	bool useSystemAppearanceForScrollbars;	222	bool useSystemAppearanceForScrollbars;
213	#endif	223	#endif
214		224
		225	#if !ENABLE(2022_GLIB_API)
215	GRefPtr<WebKitFaviconDatabase> faviconDatabase;	226	GRefPtr<WebKitFaviconDatabase> faviconDatabase;
		227	CString faviconDatabaseDirectory;
		228	#endif
216	GRefPtr<WebKitSecurityManager> securityManager;	229	GRefPtr<WebKitSecurityManager> securityManager;
217	URISchemeHandlerMap uriSchemeHandlers;	230	URISchemeHandlerMap uriSchemeHandlers;
218	GRefPtr<WebKitGeolocationManager> geolocationManager;	231	GRefPtr<WebKitGeolocationManager> geolocationManager;
219	std::unique_ptr<WebKitNotificationProvider> notificationProvider;	232	std::unique_ptr<WebKitNotificationProvider> notificationProvider;
		233	#if !ENABLE(2022_GLIB_API)
220	GRefPtr<WebKitWebsiteDataManager> websiteDataManager;	234	GRefPtr<WebKitWebsiteDataManager> websiteDataManager;
		235	#endif
221		236
222	CString faviconDatabaseDirectory;
223	WebKitProcessModel processModel;	237	WebKitProcessModel processModel;
224		238
225	HashMap<WebPageProxyIdentifier, WebKitWebView*> webViews;	239	HashMap<WebPageProxyIdentifier, WebKitWebView*> webViews;
Lines 234-244 struct _WebKitWebContextPrivate { a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec6
234	#endif	248	#endif
235	std::unique_ptr<WebKitAutomationClient> automationClient;	249	std::unique_ptr<WebKitAutomationClient> automationClient;
236	GRefPtr<WebKitAutomationSession> automationSession;	250	GRefPtr<WebKitAutomationSession> automationSession;
		251	#if ENABLE(2022_GLIB_API)
		252	GRefPtr<WebKitNetworkSession> automationNetworkSession;
		253	#endif
237	#endif	254	#endif
238	std::unique_ptr<WebKitProtocolHandler> webkitProtocolHandler;	255	std::unique_ptr<WebKitProtocolHandler> webkitProtocolHandler;
239		256
		257	#if !ENABLE(2022_GLIB_API)
240	HashSet<String> dnsPrefetchedHosts;	258	HashSet<String> dnsPrefetchedHosts;
241	PAL::HysteresisActivity dnsPrefetchHystereris;	259	PAL::HysteresisActivity dnsPrefetchHystereris;
		260	#endif
242		261
243	WebKitMemoryPressureSettings* memoryPressureSettings;	262	WebKitMemoryPressureSettings* memoryPressureSettings;
244		263
Lines 298-304 void webkitWebContextWillCloseAutomationSession(WebKitWebContext* webContext) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec7
298	{	317	{
299	webContext->priv->processPool->setAutomationSession(nullptr);	318	webContext->priv->processPool->setAutomationSession(nullptr);
300	webContext->priv->automationSession = nullptr;	319	webContext->priv->automationSession = nullptr;
		320	webContext->priv->automationNetworkSession = nullptr;
301	}	321	}
		322
		323	#if ENABLE(2022_GLIB_API)
		324	WebKitNetworkSession* webkitWebContextGetNetworkSessionForAutomation(WebKitWebContext* webContext)
		325	{
		326	if (!webContext->priv->automationNetworkSession && webContext->priv->automationClient)
		327	webContext->priv->automationNetworkSession = adoptGRef(webkit_network_session_new_ephemeral());
		328	return webContext->priv->automationNetworkSession.get();
		329	}
		330	#endif
302	#endif // ENABLE(REMOTE_INSPECTOR)	331	#endif // ENABLE(REMOTE_INSPECTOR)
303		332
304	WEBKIT_DEFINE_TYPE(WebKitWebContext, webkit_web_context, G_TYPE_OBJECT)	333	WEBKIT_DEFINE_TYPE(WebKitWebContext, webkit_web_context, G_TYPE_OBJECT)
Lines 337-345 static void webkitWebContextGetProperty(GObject* object, guint propID, GValue* v a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec8
337	g_value_set_string(value, context->priv->localStorageDirectory.data());	366	g_value_set_string(value, context->priv->localStorageDirectory.data());
338	break;	367	break;
339	#endif	368	#endif
		369	#if !ENABLE(2022_GLIB_API)
340	case PROP_WEBSITE_DATA_MANAGER:	370	case PROP_WEBSITE_DATA_MANAGER:
341	g_value_set_object(value, webkit_web_context_get_website_data_manager(context));	371	g_value_set_object(value, webkit_web_context_get_website_data_manager(context));
342	break;	372	break;
		373	#endif
343	#if PLATFORM(GTK) && !USE(GTK4)	374	#if PLATFORM(GTK) && !USE(GTK4)
344	case PROP_PSON_ENABLED:	375	case PROP_PSON_ENABLED:
345	g_value_set_boolean(value, context->priv->psonEnabled);	376	g_value_set_boolean(value, context->priv->psonEnabled);
Lines 366-376 static void webkitWebContextSetProperty(GObject* object, guint propID, const GVa a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec9
366	context->priv->localStorageDirectory = g_value_get_string(value);	397	context->priv->localStorageDirectory = g_value_get_string(value);
367	break;	398	break;
368	#endif	399	#endif
		400	#if !ENABLE(2022_GLIB_API)
369	case PROP_WEBSITE_DATA_MANAGER: {	401	case PROP_WEBSITE_DATA_MANAGER: {
370	gpointer manager = g_value_get_object(value);	402	gpointer manager = g_value_get_object(value);
371	context->priv->websiteDataManager = manager ? WEBKIT_WEBSITE_DATA_MANAGER(manager) : nullptr;	403	context->priv->websiteDataManager = manager ? WEBKIT_WEBSITE_DATA_MANAGER(manager) : nullptr;
372	break;	404	break;
373	}	405	}
		406	#endif
374	#if PLATFORM(GTK) && !USE(GTK4)	407	#if PLATFORM(GTK) && !USE(GTK4)
375	case PROP_PSON_ENABLED:	408	case PROP_PSON_ENABLED:
376	context->priv->psonEnabled = g_value_get_boolean(value);	409	context->priv->psonEnabled = g_value_get_boolean(value);
Lines 420-432 static void webkitWebContextConstructed(GObject* object) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec10
420	}	453	}
421	configuration.setTimeZoneOverride(String::fromUTF8(priv->timeZoneOverride.data(), priv->timeZoneOverride.length()));	454	configuration.setTimeZoneOverride(String::fromUTF8(priv->timeZoneOverride.data(), priv->timeZoneOverride.length()));
422		455
423	if (!priv->websiteDataManager) {
424	priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new(
425	#if !ENABLE(2022_GLIB_API)	456	#if !ENABLE(2022_GLIB_API)
426	"local-storage-directory", priv->localStorageDirectory.data(),	457	if (!priv->websiteDataManager)
		458	priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new("local-storage-directory", priv->localStorageDirectory.data(), nullptr));
427	#endif	459	#endif
428	nullptr));
429	}
430		460
431	priv->processPool = WebProcessPool::create(configuration);	461	priv->processPool = WebProcessPool::create(configuration);
432	priv->processPool->setUserMessageHandler([webContext](UserMessage&& message, CompletionHandler<void(UserMessage&&)>&& completionHandler) {	462	priv->processPool->setUserMessageHandler([webContext](UserMessage&& message, CompletionHandler<void(UserMessage&&)>&& completionHandler) {
Lines 465-474 static void webkitWebContextDispose(GObject* object) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec11
465	priv->processPool->setInjectedBundleClient(nullptr);	495	priv->processPool->setInjectedBundleClient(nullptr);
466	}	496	}
467		497
		498	#if !ENABLE(2022_GLIB_API)
468	if (priv->faviconDatabase) {	499	if (priv->faviconDatabase) {
469	webkitFaviconDatabaseClose(priv->faviconDatabase.get());	500	webkitFaviconDatabaseClose(priv->faviconDatabase.get());
470	priv->faviconDatabase = nullptr;	501	priv->faviconDatabase = nullptr;
471	}	502	}
		503	#endif
472		504
473	if (priv->processPool) {	505	if (priv->processPool) {
474	priv->processPool->setUserMessageHandler(nullptr);	506	priv->processPool->setUserMessageHandler(nullptr);
Lines 512-517 static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec12
512	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));	544	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));
513	#endif	545	#endif
514		546
		547	#if !ENABLE(2022_GLIB_API)
515	/**	548	/**
516	* WebKitWebContext:website-data-manager:	549	* WebKitWebContext:website-data-manager:
517	*	550	*
Lines 525-530 static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec13
525	nullptr, nullptr,	558	nullptr, nullptr,
526	WEBKIT_TYPE_WEBSITE_DATA_MANAGER,	559	WEBKIT_TYPE_WEBSITE_DATA_MANAGER,
527	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));	560	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));
		561	#endif
528		562
529	#if PLATFORM(GTK) && !USE(GTK4)	563	#if PLATFORM(GTK) && !USE(GTK4)
530	/**	564	/**
Lines 603-608 static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec14
603		637
604	g_object_class_install_properties(gObjectClass, N_PROPERTIES, sObjProperties);	638	g_object_class_install_properties(gObjectClass, N_PROPERTIES, sObjProperties);
605		639
		640	#if !ENABLE(2022_GLIB_API)
606	/**	641	/**
607	* WebKitWebContext::download-started:	642	* WebKitWebContext::download-started:
608	* @context: the #WebKitWebContext	643	* @context: the #WebKitWebContext
Lines 619-624 static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec15
619	g_cclosure_marshal_VOID__OBJECT,	654	g_cclosure_marshal_VOID__OBJECT,
620	G_TYPE_NONE, 1,	655	G_TYPE_NONE, 1,
621	WEBKIT_TYPE_DOWNLOAD);	656	WEBKIT_TYPE_DOWNLOAD);
		657	#endif
622		658
623	/**	659	/**
624	* WebKitWebContext::initialize-web-extensions:	660	* WebKitWebContext::initialize-web-extensions:
Lines 745-750 WebKitWebContext* webkit_web_context_new(void) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec16
745	return WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT, nullptr));	781	return WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT, nullptr));
746	}	782	}
747		783
		784	#if !ENABLE(2022_GLIB_API)
748	/**	785	/**
749	* webkit_web_context_new_ephemeral:	786	* webkit_web_context_new_ephemeral:
750	*	787	*
Lines 817-822 gboolean webkit_web_context_is_ephemeral(WebKitWebContext* context) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec17
817		854
818	return webkit_website_data_manager_is_ephemeral(context->priv->websiteDataManager.get());	855	return webkit_website_data_manager_is_ephemeral(context->priv->websiteDataManager.get());
819	}	856	}
		857	#endif
820		858
821	/**	859	/**
822	* webkit_web_context_is_automation_allowed:	860	* webkit_web_context_is_automation_allowed:
Lines 955-960 WebKitCacheModel webkit_web_context_get_cache_model(WebKitWebContext* context) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec18
955	return WEBKIT_CACHE_MODEL_WEB_BROWSER;	993	return WEBKIT_CACHE_MODEL_WEB_BROWSER;
956	}	994	}
957		995
		996	#if !ENABLE(2022_GLIB_API)
958	/**	997	/**
959	* webkit_web_context_clear_cache:	998	* webkit_web_context_clear_cache:
960	* @context: a #WebKitWebContext	999	* @context: a #WebKitWebContext
Lines 974-980 void webkit_web_context_clear_cache(WebKitWebContext* context) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec19
974	websiteDataStore.removeData(websiteDataTypes, -WallTime::infinity(), [] { });	1013	websiteDataStore.removeData(websiteDataTypes, -WallTime::infinity(), [] { });
975	}	1014	}
976		1015
977	#if !ENABLE(2022_GLIB_API)
978	/**	1016	/**
979	* webkit_web_context_set_network_proxy_settings:	1017	* webkit_web_context_set_network_proxy_settings:
980	* @context: a #WebKitWebContext	1018	* @context: a #WebKitWebContext
Lines 1001-1007 void webkit_web_context_set_network_proxy_settings(WebKitWebContext* context, We a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec20
1001		1039
1002	webkit_website_data_manager_set_network_proxy_settings(context->priv->websiteDataManager.get(), proxyMode, proxySettings);	1040	webkit_website_data_manager_set_network_proxy_settings(context->priv->websiteDataManager.get(), proxyMode, proxySettings);
1003	}	1041	}
1004	#endif
1005		1042
1006	/**	1043	/**
1007	* webkit_web_context_download_uri:	1044	* webkit_web_context_download_uri:
Lines 1050-1055 WebKitCookieManager* webkit_web_context_get_cookie_manager(WebKitWebContext* con a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec21
1050		1087
1051	return webkit_website_data_manager_get_cookie_manager(context->priv->websiteDataManager.get());	1088	return webkit_website_data_manager_get_cookie_manager(context->priv->websiteDataManager.get());
1052	}	1089	}
		1090	#endif
1053		1091
1054	/**	1092	/**
1055	* webkit_web_context_get_geolocation_manager:	1093	* webkit_web_context_get_geolocation_manager:
Lines 1068-1073 WebKitGeolocationManager* webkit_web_context_get_geolocation_manager(WebKitWebCo a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec22
1068	return context->priv->geolocationManager.get();	1106	return context->priv->geolocationManager.get();
1069	}	1107	}
1070		1108
		1109	#if !ENABLE(2022_GLIB_API)
1071	static void ensureFaviconDatabase(WebKitWebContext* context)	1110	static void ensureFaviconDatabase(WebKitWebContext* context)
1072	{	1111	{
1073	WebKitWebContextPrivate* priv = context->priv;	1112	WebKitWebContextPrivate* priv = context->priv;
Lines 1169-1174 WebKitFaviconDatabase* webkit_web_context_get_favicon_database(WebKitWebContext* a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec23
1169	ensureFaviconDatabase(context);	1208	ensureFaviconDatabase(context);
1170	return context->priv->faviconDatabase.get();	1209	return context->priv->faviconDatabase.get();
1171	}	1210	}
		1211	#endif
1172		1212
1173	/**	1213	/**
1174	* webkit_web_context_get_security_manager:	1214	* webkit_web_context_get_security_manager:
Lines 1656-1661 void webkit_web_context_set_disk_cache_directory(WebKitWebContext, const char) a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec24
1656	}	1696	}
1657	#endif	1697	#endif
1658		1698
		1699	#if !ENABLE(2022_GLIB_API)
1659	/**	1700	/**
1660	* webkit_web_context_prefetch_dns:	1701	* webkit_web_context_prefetch_dns:
1661	* @context: a #WebKitWebContext	1702	* @context: a #WebKitWebContext
Lines 1671-1678 void webkit_web_context_prefetch_dns(WebKitWebContext* context, const char* host a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec25
1671	g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));	1712	g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
1672	g_return_if_fail(hostname);	1713	g_return_if_fail(hostname);
1673		1714
1674	auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(context->priv->websiteDataManager.get());	1715	if (context->priv->dnsPrefetchedHosts.add(hostname).isNewEntry) {
1675	websiteDataStore.networkProcess().send(Messages::NetworkProcess::PrefetchDNS(String::fromUTF8(hostname)), 0);	1716	auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(context->priv->websiteDataManager.get());
		1717	websiteDataStore.networkProcess().send(Messages::NetworkProcess::PrefetchDNS(String::fromUTF8(hostname)), 0);
		1718	}
1676	context->priv->dnsPrefetchHystereris.impulse();	1719	context->priv->dnsPrefetchHystereris.impulse();
1677	}	1720	}
1678		1721
Lines 1696-1701 void webkit_web_context_allow_tls_certificate_for_host(WebKitWebContext* context a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec26
1696	auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(context->priv->websiteDataManager.get());	1739	auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(context->priv->websiteDataManager.get());
1697	websiteDataStore.allowSpecificHTTPSCertificateForHost(certificateInfo, String::fromUTF8(host));	1740	websiteDataStore.allowSpecificHTTPSCertificateForHost(certificateInfo, String::fromUTF8(host));
1698	}	1741	}
		1742	#endif
1699		1743
1700	/**	1744	/**
1701	* webkit_web_context_set_process_model:	1745	* webkit_web_context_set_process_model:
Lines 1936-1945 void webkitWebContextInitializeNotificationPermissions(WebKitWebContext* context a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec27
1936	g_signal_emit(context, signals[INITIALIZE_NOTIFICATION_PERMISSIONS], 0);	1980	g_signal_emit(context, signals[INITIALIZE_NOTIFICATION_PERMISSIONS], 0);
1937	}	1981	}
1938		1982
		1983	#if !ENABLE(2022_GLIB_API)
1939	void webkitWebContextDownloadStarted(WebKitWebContext* context, WebKitDownload* download)	1984	void webkitWebContextDownloadStarted(WebKitWebContext* context, WebKitDownload* download)
1940	{	1985	{
1941	g_signal_emit(context, signals[DOWNLOAD_STARTED], 0, download);	1986	g_signal_emit(context, signals[DOWNLOAD_STARTED], 0, download);
1942	}	1987	}
		1988	#endif
1943		1989
1944	GVariant* webkitWebContextInitializeWebExtensions(WebKitWebContext* context)	1990	GVariant* webkitWebContextInitializeWebExtensions(WebKitWebContext* context)
1945	{	1991	{
Lines 1977-1984 void webkitWebContextCreatePageForWebView(WebKitWebContext* context, WebKitWebVi a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp_sec28
1977	pageConfiguration->setOverrideContentSecurityPolicy(String::fromUTF8(defaultContentSecurityPolicy));	2023	pageConfiguration->setOverrideContentSecurityPolicy(String::fromUTF8(defaultContentSecurityPolicy));
1978		2024
1979	WebKitWebsiteDataManager* manager = webkitWebViewGetWebsiteDataManager(webView);	2025	WebKitWebsiteDataManager* manager = webkitWebViewGetWebsiteDataManager(webView);
		2026	#if !ENABLE(2022_GLIB_API)
1980	if (!manager)	2027	if (!manager)
1981	manager = context->priv->websiteDataManager.get();	2028	manager = context->priv->websiteDataManager.get();
		2029	#endif
1982	pageConfiguration->setWebsiteDataStore(&webkitWebsiteDataManagerGetDataStore(manager));	2030	pageConfiguration->setWebsiteDataStore(&webkitWebsiteDataManagerGetDataStore(manager));
1983	pageConfiguration->setDefaultWebsitePolicies(webkitWebsitePoliciesGetWebsitePolicies(defaultWebsitePolicies));	2031	pageConfiguration->setDefaultWebsitePolicies(webkitWebsitePoliciesGetWebsitePolicies(defaultWebsitePolicies));
1984	webkitWebViewCreatePage(webView, WTFMove(pageConfiguration));	2032	webkitWebViewCreatePage(webView, WTFMove(pageConfiguration));



#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>

WEBKIT_API WebKitWebContext *
webkit_web_context_new                              (void);

#if !ENABLE(2022_GLIB_API)
WEBKIT_API WebKitWebContext *
webkit_web_context_new_ephemeral                    (void);



WEBKIT_API gboolean
webkit_web_context_is_ephemeral                     (WebKitWebContext              *context);
#endif

WEBKIT_API gboolean
webkit_web_context_is_automation_allowed            (WebKitWebContext              *context);

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,


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);


                                                     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);

Lines 31-38 a/Source/WebKit/UIProcess/API/glib/WebKitWebContextPrivate.h_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitWebContextPrivate.h +9 lines
31	#include "WebProcessPool.h"	31	#include "WebProcessPool.h"
32	#include <WebCore/ResourceRequest.h>	32	#include <WebCore/ResourceRequest.h>
33		33
		34	#if ENABLE(2022_GLIB_API)
		35	#include "WebKitNetworkSession.h"
		36	#endif
		37
34	WebKit::WebProcessPool& webkitWebContextGetProcessPool(WebKitWebContext*);	38	WebKit::WebProcessPool& webkitWebContextGetProcessPool(WebKitWebContext*);
		39	#if !ENABLE(2022_GLIB_API)
35	void webkitWebContextDownloadStarted(WebKitWebContext, WebKitDownload);	40	void webkitWebContextDownloadStarted(WebKitWebContext, WebKitDownload);
		41	#endif
36	void webkitWebContextCreatePageForWebView(WebKitWebContext, WebKitWebView, WebKitUserContentManager, WebKitWebView, WebKitWebsitePolicies*);	42	void webkitWebContextCreatePageForWebView(WebKitWebContext, WebKitWebView, WebKitUserContentManager, WebKitWebView, WebKitWebsitePolicies*);
37	void webkitWebContextWebViewDestroyed(WebKitWebContext, WebKitWebView);	43	void webkitWebContextWebViewDestroyed(WebKitWebContext, WebKitWebView);
38	WebKitWebView* webkitWebContextGetWebViewForPage(WebKitWebContext, WebKit::WebPageProxy);	44	WebKitWebView* webkitWebContextGetWebViewForPage(WebKitWebContext, WebKit::WebPageProxy);
Lines 40-43 GVariant* webkitWebContextInitializeWebExtensions(WebKitWebContext*); a/Source/WebKit/UIProcess/API/glib/WebKitWebContextPrivate.h_sec2
40	void webkitWebContextInitializeNotificationPermissions(WebKitWebContext*);	46	void webkitWebContextInitializeNotificationPermissions(WebKitWebContext*);
41	#if ENABLE(REMOTE_INSPECTOR)	47	#if ENABLE(REMOTE_INSPECTOR)
42	void webkitWebContextWillCloseAutomationSession(WebKitWebContext*);	48	void webkitWebContextWillCloseAutomationSession(WebKitWebContext*);
		49	#if ENABLE(2022_GLIB_API)
		50	WebKitNetworkSession* webkitWebContextGetNetworkSessionForAutomation(WebKitWebContext*);
		51	#endif
43	#endif	52	#endif

Lines 102-107 a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp -21 / +150 lines
102	#include "WebKitWebViewClient.h"	102	#include "WebKitWebViewClient.h"
103	#endif	103	#endif
104		104
		105	#if ENABLE(2022_GLIB_API)
		106	#include "WebKitNetworkSessionPrivate.h"
		107	#endif
		108
105	using namespace WebKit;	109	using namespace WebKit;
106	using namespace WebCore;	110	using namespace WebCore;
107		111
Lines 187-192 enum { a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec2
187	PROP_RELATED_VIEW,	191	PROP_RELATED_VIEW,
188	PROP_SETTINGS,	192	PROP_SETTINGS,
189	PROP_USER_CONTENT_MANAGER,	193	PROP_USER_CONTENT_MANAGER,
		194	#if ENABLE(2022_GLIB_API)
		195	PROP_NETWORK_SESSION,
		196	#endif
190	PROP_TITLE,	197	PROP_TITLE,
191	PROP_ESTIMATED_LOAD_PROGRESS,	198	PROP_ESTIMATED_LOAD_PROGRESS,
192		199
Lines 198-204 enum { a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec3
198	PROP_ZOOM_LEVEL,	205	PROP_ZOOM_LEVEL,
199	PROP_IS_LOADING,	206	PROP_IS_LOADING,
200	PROP_IS_PLAYING_AUDIO,	207	PROP_IS_PLAYING_AUDIO,
		208	#if !ENABLE(2022_GLIB_API)
201	PROP_IS_EPHEMERAL,	209	PROP_IS_EPHEMERAL,
		210	#endif
202	PROP_IS_CONTROLLED_BY_AUTOMATION,	211	PROP_IS_CONTROLLED_BY_AUTOMATION,
203	PROP_AUTOMATION_PRESENTATION_TYPE,	212	PROP_AUTOMATION_PRESENTATION_TYPE,
204	PROP_EDITABLE,	213	PROP_EDITABLE,
Lines 273-279 struct _WebKitWebViewPrivate { a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec4
273	CString activeURI;	282	CString activeURI;
274	bool isActiveURIChangeBlocked;	283	bool isActiveURIChangeBlocked;
275	bool isLoading;	284	bool isLoading;
		285	#if !ENABLE(2022_GLIB_API)
276	bool isEphemeral;	286	bool isEphemeral;
		287	#endif
277	bool isControlledByAutomation;	288	bool isControlledByAutomation;
278	WebKitAutomationBrowsingContextPresentation automationPresentationType;	289	WebKitAutomationBrowsingContextPresentation automationPresentationType;
279		290
Lines 312-318 struct _WebKitWebViewPrivate { a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec5
312		323
313	GRefPtr<WebKitAuthenticationRequest> authenticationRequest;	324	GRefPtr<WebKitAuthenticationRequest> authenticationRequest;
314		325
		326	#if ENABLE(2022_GLIB_API)
		327	GRefPtr<WebKitNetworkSession> networkSession;
		328	#else
315	GRefPtr<WebKitWebsiteDataManager> websiteDataManager;	329	GRefPtr<WebKitWebsiteDataManager> websiteDataManager;
		330	#endif
316	GRefPtr<WebKitWebsitePolicies> websitePolicies;	331	GRefPtr<WebKitWebsitePolicies> websitePolicies;
317		332
318	CString defaultContentSecurityPolicy;	333	CString defaultContentSecurityPolicy;
Lines 581-586 static void userAgentChanged(WebKitSettings* settings, GParamSpec*, WebKitWebVie a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec6
581	getPage(webView).setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));	596	getPage(webView).setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));
582	}	597	}
583		598
		599	static gboolean webkitWebViewIsEphemeral(WebKitWebView* webView)
		600	{
		601	#if ENABLE(2022_GLIB_API)
		602	return webkit_network_session_is_ephemeral(webView->priv->networkSession.get());
		603	#else
		604	return webView->priv->isEphemeral;
		605	#endif
		606	}
		607
584	#if PLATFORM(GTK)	608	#if PLATFORM(GTK)
585	static void enableBackForwardNavigationGesturesChanged(WebKitSettings* settings, GParamSpec, WebKitWebView webView)	609	static void enableBackForwardNavigationGesturesChanged(WebKitSettings* settings, GParamSpec, WebKitWebView webView)
586	{	610	{
Lines 619-632 static void gotFaviconCallback(GObject* object, GAsyncResult* result, gpointer u a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec7
619	webView->priv->faviconCancellable = 0;	643	webView->priv->faviconCancellable = 0;
620	}	644	}
621		645
		646	static WebKitFaviconDatabase* webkitWebViewGetFaviconDatabase(WebKitWebView* webView)
		647	{
		648	#if ENABLE(2022_GLIB_API)
		649	return webkit_website_data_manager_get_favicon_database(webkitWebViewGetWebsiteDataManager(webView));
		650	#else
		651	return webkit_web_context_get_favicon_database(priv->context.get());
		652	#endif
		653	}
		654
622	static void webkitWebViewRequestFavicon(WebKitWebView* webView)	655	static void webkitWebViewRequestFavicon(WebKitWebView* webView)
623	{	656	{
624	webkitWebViewCancelFaviconRequest(webView);	657	webkitWebViewCancelFaviconRequest(webView);
625		658
626	WebKitWebViewPrivate* priv = webView->priv;	659	WebKitWebViewPrivate* priv = webView->priv;
		660	auto* database = webkitWebViewGetFaviconDatabase(webView);
		661	if (!database)
		662	return;
		663
627	priv->faviconCancellable = adoptGRef(g_cancellable_new());	664	priv->faviconCancellable = adoptGRef(g_cancellable_new());
628	WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());	665	webkitFaviconDatabaseGetFaviconInternal(database, priv->activeURI.data(), webkitWebViewIsEphemeral(webView), priv->faviconCancellable.get(), gotFaviconCallback, webView);
629	webkitFaviconDatabaseGetFaviconInternal(database, priv->activeURI.data(), priv->isEphemeral, priv->faviconCancellable.get(), gotFaviconCallback, webView);
630	}	666	}
631		667
632	static void webkitWebViewUpdateFaviconURI(WebKitWebView* webView, const char* faviconURI)	668	static void webkitWebViewUpdateFaviconURI(WebKitWebView* webView, const char* faviconURI)
Lines 701-716 static void webkitWebViewWatchForChangesInFavicon(WebKitWebView* webView) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec8
701	if (priv->faviconChangedHandlerID)	737	if (priv->faviconChangedHandlerID)
702	return;	738	return;
703		739
704	WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());	740	auto* database = webkitWebViewGetFaviconDatabase(webView);
705	priv->faviconChangedHandlerID = g_signal_connect(database, "favicon-changed", G_CALLBACK(faviconChangedCallback), webView);	741	if (!database)
706	}	742	return;
707		743
708	static void webkitWebViewDisconnectFaviconDatabaseSignalHandlers(WebKitWebView* webView)	744	priv->faviconChangedHandlerID = g_signal_connect_object(database, "favicon-changed", G_CALLBACK(faviconChangedCallback), webView, G_CONNECT_DEFAULT);
709	{
710	WebKitWebViewPrivate* priv = webView->priv;
711	if (priv->faviconChangedHandlerID)
712	g_signal_handler_disconnect(webkit_web_context_get_favicon_database(priv->context.get()), priv->faviconChangedHandlerID);
713	priv->faviconChangedHandlerID = 0;
714	}	745	}
715	#endif	746	#endif
716		747
Lines 722-733 static void webkitWebViewConstructed(GObject* object) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec9
722	WebKitWebViewPrivate* priv = webView->priv;	753	WebKitWebViewPrivate* priv = webView->priv;
723	if (priv->relatedView) {	754	if (priv->relatedView) {
724	priv->context = webkit_web_view_get_context(priv->relatedView);	755	priv->context = webkit_web_view_get_context(priv->relatedView);
		756	priv->networkSession = webkit_web_view_get_network_session(priv->relatedView);
		757	#if !ENABLE(2022_GLIB_API)
725	priv->isEphemeral = webkit_web_view_is_ephemeral(priv->relatedView);	758	priv->isEphemeral = webkit_web_view_is_ephemeral(priv->relatedView);
		759	#endif
726	priv->isControlledByAutomation = webkit_web_view_is_controlled_by_automation(priv->relatedView);	760	priv->isControlledByAutomation = webkit_web_view_is_controlled_by_automation(priv->relatedView);
727	} else if (!priv->context)	761	} else if (!priv->context)
728	priv->context = webkit_web_context_get_default();	762	priv->context = webkit_web_context_get_default();
		763	#if !ENABLE(2022_GLIB_API)
729	else if (!priv->isEphemeral)	764	else if (!priv->isEphemeral)
730	priv->isEphemeral = webkit_web_context_is_ephemeral(priv->context.get());	765	priv->isEphemeral = webkit_web_context_is_ephemeral(priv->context.get());
		766	#endif
731		767
732	if (!priv->settings)	768	if (!priv->settings)
733	priv->settings = adoptGRef(webkit_settings_new());	769	priv->settings = adoptGRef(webkit_settings_new());
Lines 735-740 static void webkitWebViewConstructed(GObject* object) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec10
735	if (!priv->userContentManager)	771	if (!priv->userContentManager)
736	priv->userContentManager = adoptGRef(webkit_user_content_manager_new());	772	priv->userContentManager = adoptGRef(webkit_user_content_manager_new());
737		773
		774	#if ENABLE(2022_GLIB_API)
		775	#if ENABLE(REMOTE_INSPECTOR)
		776	if (priv->isControlledByAutomation)
		777	priv->networkSession = webkitWebContextGetNetworkSessionForAutomation(priv->context.get());
		778	#endif
		779	if (!priv->networkSession)
		780	priv->networkSession = webkit_network_session_get_default();
		781	#else
738	if (priv->isEphemeral && !webkit_web_context_is_ephemeral(priv->context.get())) {	782	if (priv->isEphemeral && !webkit_web_context_is_ephemeral(priv->context.get())) {
739	priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new_ephemeral());	783	priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new_ephemeral());
740	auto* contextDataManager = webkit_web_context_get_website_data_manager(priv->context.get());	784	auto* contextDataManager = webkit_web_context_get_website_data_manager(priv->context.get());
Lines 742-747 static void webkitWebViewConstructed(GObject* object) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec11
742	auto proxySettings = webkitWebsiteDataManagerGetDataStore(contextDataManager).networkProxySettings();	786	auto proxySettings = webkitWebsiteDataManagerGetDataStore(contextDataManager).networkProxySettings();
743	webkitWebsiteDataManagerGetDataStore(priv->websiteDataManager.get()).setNetworkProxySettings(WTFMove(proxySettings));	787	webkitWebsiteDataManagerGetDataStore(priv->websiteDataManager.get()).setNetworkProxySettings(WTFMove(proxySettings));
744	}	788	}
		789	#endif
745		790
746	if (!priv->websitePolicies)	791	if (!priv->websitePolicies)
747	priv->websitePolicies = adoptGRef(webkit_website_policies_new());	792	priv->websitePolicies = adoptGRef(webkit_website_policies_new());
Lines 824-835 static void webkitWebViewSetProperty(GObject* object, guint propId, const GValue a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec12
824	webView->priv->userContentManager = userContentManager ? WEBKIT_USER_CONTENT_MANAGER(userContentManager) : nullptr;	869	webView->priv->userContentManager = userContentManager ? WEBKIT_USER_CONTENT_MANAGER(userContentManager) : nullptr;
825	break;	870	break;
826	}	871	}
		872	#if ENABLE(2022_GLIB_API)
		873	case PROP_NETWORK_SESSION: {
		874	gpointer networkSession = g_value_get_object(value);
		875	webView->priv->networkSession = networkSession ? WEBKIT_NETWORK_SESSION(networkSession) : nullptr;
		876	break;
		877	}
		878	#endif
827	case PROP_ZOOM_LEVEL:	879	case PROP_ZOOM_LEVEL:
828	webkit_web_view_set_zoom_level(webView, g_value_get_double(value));	880	webkit_web_view_set_zoom_level(webView, g_value_get_double(value));
829	break;	881	break;
		882	#if !ENABLE(2022_GLIB_API)
830	case PROP_IS_EPHEMERAL:	883	case PROP_IS_EPHEMERAL:
831	webView->priv->isEphemeral = g_value_get_boolean(value);	884	webView->priv->isEphemeral = g_value_get_boolean(value);
832	break;	885	break;
		886	#endif
833	case PROP_IS_CONTROLLED_BY_AUTOMATION:	887	case PROP_IS_CONTROLLED_BY_AUTOMATION:
834	webView->priv->isControlledByAutomation = g_value_get_boolean(value);	888	webView->priv->isControlledByAutomation = g_value_get_boolean(value);
835	break;	889	break;
Lines 884-889 static void webkitWebViewGetProperty(GObject* object, guint propId, GValue* valu a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec13
884	case PROP_USER_CONTENT_MANAGER:	938	case PROP_USER_CONTENT_MANAGER:
885	g_value_set_object(value, webkit_web_view_get_user_content_manager(webView));	939	g_value_set_object(value, webkit_web_view_get_user_content_manager(webView));
886	break;	940	break;
		941	#if ENABLE(2022_GLIB_API)
		942	case PROP_NETWORK_SESSION:
		943	g_value_set_object(value, webkit_web_view_get_network_session(webView));
		944	break;
		945	#endif
887	case PROP_TITLE:	946	case PROP_TITLE:
888	g_value_set_string(value, webView->priv->title.data());	947	g_value_set_string(value, webView->priv->title.data());
889	break;	948	break;
Lines 907-915 static void webkitWebViewGetProperty(GObject* object, guint propId, GValue* valu a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec14
907	case PROP_IS_PLAYING_AUDIO:	966	case PROP_IS_PLAYING_AUDIO:
908	g_value_set_boolean(value, webkit_web_view_is_playing_audio(webView));	967	g_value_set_boolean(value, webkit_web_view_is_playing_audio(webView));
909	break;	968	break;
		969	#if !ENABLE(2022_GLIB_API)
910	case PROP_IS_EPHEMERAL:	970	case PROP_IS_EPHEMERAL:
911	g_value_set_boolean(value, webkit_web_view_is_ephemeral(webView));	971	g_value_set_boolean(value, webkit_web_view_is_ephemeral(webView));
912	break;	972	break;
		973	#endif
913	case PROP_IS_CONTROLLED_BY_AUTOMATION:	974	case PROP_IS_CONTROLLED_BY_AUTOMATION:
914	g_value_set_boolean(value, webkit_web_view_is_controlled_by_automation(webView));	975	g_value_set_boolean(value, webkit_web_view_is_controlled_by_automation(webView));
915	break;	976	break;
Lines 957-963 static void webkitWebViewDispose(GObject* object) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec15
957		1018
958	#if PLATFORM(GTK)	1019	#if PLATFORM(GTK)
959	webkitWebViewCancelFaviconRequest(webView);	1020	webkitWebViewCancelFaviconRequest(webView);
960	webkitWebViewDisconnectFaviconDatabaseSignalHandlers(webView);	1021	webView->priv->faviconChangedHandlerID = 0;
961	#endif	1022	#endif
962		1023
963	webkitWebViewDisconnectSettingsSignalHandlers(webView);	1024	webkitWebViewDisconnectSettingsSignalHandlers(webView);
Lines 1083-1088 static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec16
1083	WEBKIT_TYPE_USER_CONTENT_MANAGER,	1144	WEBKIT_TYPE_USER_CONTENT_MANAGER,
1084	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));	1145	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));
1085		1146
		1147	#if ENABLE(2022_GLIB_API)
		1148	/**
		1149	* WebKitWebView:network-session:
		1150	*
		1151	* The #WebKitNetworkSession of the view
		1152	*
		1153	* Since: 2.40
		1154	*/
		1155	sObjProperties[PROP_NETWORK_SESSION]=
		1156	g_param_spec_object(
		1157	"network-session",
		1158	_("WebView network session"),
		1159	_("The WebKitNetworkSession of the view"),
		1160	WEBKIT_TYPE_NETWORK_SESSION,
		1161	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));
		1162	#endif
		1163
1086	/**	1164	/**
1087	* WebKitWebView:title:	1165	* WebKitWebView:title:
1088	*	1166	*
Lines 1188-1193 static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec17
1188	FALSE,	1266	FALSE,
1189	WEBKIT_PARAM_READABLE);	1267	WEBKIT_PARAM_READABLE);
1190		1268
		1269	#if !ENABLE(2022_GLIB_API)
1191	/**	1270	/**
1192	* WebKitWebView:is-ephemeral:	1271	* WebKitWebView:is-ephemeral:
1193	*	1272	*
Lines 1212-1217 static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec18
1212	nullptr, nullptr,	1291	nullptr, nullptr,
1213	FALSE,	1292	FALSE,
1214	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));	1293	static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY));
		1294	#endif
1215		1295
1216	/**	1296	/**
1217	* WebKitWebView:is-controlled-by-automation:	1297	* WebKitWebView:is-controlled-by-automation:
Lines 2334-2342 void webkitWebViewLoadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec19
2334	g_object_notify_by_pspec(G_OBJECT(webView), sObjProperties[PROP_URI]);	2414	g_object_notify_by_pspec(G_OBJECT(webView), sObjProperties[PROP_URI]);
2335	}	2415	}
2336	#if PLATFORM(GTK)	2416	#if PLATFORM(GTK)
2337	WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());	2417	if (auto* database = webkitWebViewGetFaviconDatabase(webView)) {
2338	GUniquePtr<char> faviconURI(webkit_favicon_database_get_favicon_uri(database, priv->activeURI.data()));	2418	GUniquePtr<char> faviconURI(webkit_favicon_database_get_favicon_uri(database, priv->activeURI.data()));
2339	webkitWebViewUpdateFaviconURI(webView, faviconURI.get());	2419	webkitWebViewUpdateFaviconURI(webView, faviconURI.get());
		2420	}
2340	#endif	2421	#endif
2341	break;	2422	break;
2342	}	2423	}
Lines 2363-2370 void webkitWebViewLoadFailedWithTLSErrors(WebKitWebView* webView, const char* fa a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec20
2363	{	2444	{
2364	webkitWebViewCompleteAuthenticationRequest(webView);	2445	webkitWebViewCompleteAuthenticationRequest(webView);
2365		2446
		2447	#if ENABLE(2022_GLIB_API)
		2448	WebKitTLSErrorsPolicy tlsErrorsPolicy = webkit_network_session_get_tls_errors_policy(webView->priv->networkSession.get());
		2449	#else
2366	auto* websiteDataManager = webkit_web_view_get_website_data_manager(webView);	2450	auto* websiteDataManager = webkit_web_view_get_website_data_manager(webView);
2367	WebKitTLSErrorsPolicy tlsErrorsPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	2451	WebKitTLSErrorsPolicy tlsErrorsPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
		2452	#endif
2368	if (tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_FAIL) {	2453	if (tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_FAIL) {
2369	gboolean returnValue;	2454	gboolean returnValue;
2370	g_signal_emit(webView, signals[LOAD_FAILED_WITH_TLS_ERRORS], 0, failingURI, certificate, tlsErrors, &returnValue);	2455	g_signal_emit(webView, signals[LOAD_FAILED_WITH_TLS_ERRORS], 0, failingURI, certificate, tlsErrors, &returnValue);
Lines 2383-2396 void webkitWebViewGetLoadDecisionForIcon(WebKitWebView* webView, const LinkIcon& a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec21
2383	completionHandler(false);	2468	completionHandler(false);
2384	return;	2469	return;
2385	}	2470	}
2386	WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(webView->priv->context.get());	2471
2387	webkitFaviconDatabaseGetLoadDecisionForIcon(database, icon, getPage(webView).pageLoadState().activeURL(), webView->priv->isEphemeral, WTFMove(completionHandler));	2472	auto* database = webkitWebViewGetFaviconDatabase(webView);
		2473	if (!database)
		2474	return;
		2475
		2476	webkitFaviconDatabaseGetLoadDecisionForIcon(database, icon, getPage(webView).pageLoadState().activeURL(), webkitWebViewIsEphemeral(webView), WTFMove(completionHandler));
2388	}	2477	}
2389		2478
2390	void webkitWebViewSetIcon(WebKitWebView* webView, const LinkIcon& icon, API::Data& iconData)	2479	void webkitWebViewSetIcon(WebKitWebView* webView, const LinkIcon& icon, API::Data& iconData)
2391	{	2480	{
2392	WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(webView->priv->context.get());	2481	auto* database = webkitWebViewGetFaviconDatabase(webView);
2393	webkitFaviconDatabaseSetIconForPageURL(database, icon, iconData, getPage(webView).pageLoadState().activeURL(), webView->priv->isEphemeral);	2482	if (!database)
		2483	return;
		2484
		2485	webkitFaviconDatabaseSetIconForPageURL(database, icon, iconData, getPage(webView).pageLoadState().activeURL(), webkitWebViewIsEphemeral(webView));
2394	}	2486	}
2395	#endif	2487	#endif
2396		2488
Lines 2702-2710 void webkitWebViewSubmitFormRequest(WebKitWebView* webView, WebKitFormSubmission a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec22
2702		2794
2703	void webkitWebViewHandleAuthenticationChallenge(WebKitWebView* webView, AuthenticationChallengeProxy* authenticationChallenge)	2795	void webkitWebViewHandleAuthenticationChallenge(WebKitWebView* webView, AuthenticationChallengeProxy* authenticationChallenge)
2704	{	2796	{
		2797	#if ENABLE(2022_GLIB_API)
		2798	bool credenialStorageEnabled = webkit_network_session_get_persistent_credential_storage_enabled(webView->priv->networkSession.get());
		2799	#else
2705	auto* websiteDataManager = webkit_web_view_get_website_data_manager(webView);	2800	auto* websiteDataManager = webkit_web_view_get_website_data_manager(webView);
2706	webView->priv->authenticationRequest = adoptGRef(webkitAuthenticationRequestCreate(authenticationChallenge,	2801	bool credenialStorageEnabled = webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager);
2707	webView->priv->isEphemeral, webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager)));	2802	#endif
		2803	webView->priv->authenticationRequest = adoptGRef(webkitAuthenticationRequestCreate(authenticationChallenge, webkitWebViewIsEphemeral(webView), credenialStorageEnabled));
2708	gboolean returnValue;	2804	gboolean returnValue;
2709	g_signal_emit(webView, signals[AUTHENTICATE], 0, webView->priv->authenticationRequest.get(), &returnValue);	2805	g_signal_emit(webView, signals[AUTHENTICATE], 0, webView->priv->authenticationRequest.get(), &returnValue);
2710	}	2806	}
Lines 2740-2746 void webkitWebViewSelectionDidChange(WebKitWebView* webView) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec23
2740		2836
2741	WebKitWebsiteDataManager* webkitWebViewGetWebsiteDataManager(WebKitWebView* webView)	2837	WebKitWebsiteDataManager* webkitWebViewGetWebsiteDataManager(WebKitWebView* webView)
2742	{	2838	{
		2839	#if ENABLE(2022_GLIB_API)
		2840	return webkit_network_session_get_website_data_manager(webView->priv->networkSession.get());
		2841	#else
2743	return webView->priv->websiteDataManager.get();	2842	return webView->priv->websiteDataManager.get();
		2843	#endif
2744	}	2844	}
2745		2845
2746	#if PLATFORM(GTK)	2846	#if PLATFORM(GTK)
Lines 2888-2893 WebKitUserContentManager* webkit_web_view_get_user_content_manager(WebKitWebView a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec24
2888	return webView->priv->userContentManager.get();	2988	return webView->priv->userContentManager.get();
2889	}	2989	}
2890		2990
		2991	#if !ENABLE(2022_GLIB_API)
2891	/**	2992	/**
2892	* webkit_web_view_is_ephemeral:	2993	* webkit_web_view_is_ephemeral:
2893	* @web_view: a #WebKitWebView	2994	* @web_view: a #WebKitWebView
Lines 2910-2915 gboolean webkit_web_view_is_ephemeral(WebKitWebView* webView) a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec25
2910		3011
2911	return webView->priv->isEphemeral;	3012	return webView->priv->isEphemeral;
2912	}	3013	}
		3014	#endif
2913		3015
2914	/**	3016	/**
2915	* webkit_web_view_is_controlled_by_automation:	3017	* webkit_web_view_is_controlled_by_automation:
Lines 2949-2954 WebKitAutomationBrowsingContextPresentation webkit_web_view_get_automation_prese a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec26
2949	return webView->priv->automationPresentationType;	3051	return webView->priv->automationPresentationType;
2950	}	3052	}
2951		3053
		3054	#if ENABLE(2022_GLIB_API)
		3055	/**
		3056	* webkit_web_view_get_network_session:
		3057	* @web_view: a #WebKitWebView
		3058	*
		3059	* Get the #WebKitNetworkSession associated to @web_view.
		3060	*
		3061	* Returns: (transfer none): a #WebKitNetworkSession
		3062	*
		3063	* Since: 2.40
		3064	*/
		3065	WebKitNetworkSession* webkit_web_view_get_network_session(WebKitWebView* webView)
		3066	{
		3067	g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
		3068
		3069	return webView->priv->networkSession.get();
		3070	}
		3071	#else
2952	/**	3072	/**
2953	* webkit_web_view_get_website_data_manager:	3073	* webkit_web_view_get_website_data_manager:
2954	* @web_view: a #WebKitWebView	3074	* @web_view: a #WebKitWebView
Lines 2972-2977 WebKitWebsiteDataManager* webkit_web_view_get_website_data_manager(WebKitWebView a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec27
2972		3092
2973	return webkit_web_context_get_website_data_manager(webView->priv->context.get());	3093	return webkit_web_context_get_website_data_manager(webView->priv->context.get());
2974	}	3094	}
		3095	#endif
2975		3096
2976	/**	3097	/**
2977	* webkit_web_view_try_close:	3098	* webkit_web_view_try_close:
Lines 4414-4425 WebKitDownload* webkit_web_view_download_uri(WebKitWebView* webView, const char* a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp_sec28
4414	auto& page = getPage(webView);	4535	auto& page = getPage(webView);
4415	auto& downloadProxy = page.process().processPool().download(page.websiteDataStore(), &page, ResourceRequest { String::fromUTF8(uri) });	4536	auto& downloadProxy = page.process().processPool().download(page.websiteDataStore(), &page, ResourceRequest { String::fromUTF8(uri) });
4416	auto download = webkitDownloadCreate(downloadProxy, webView);	4537	auto download = webkitDownloadCreate(downloadProxy, webView);
		4538	#if ENABLE(2022_GLIB_API)
		4539	downloadProxy.setDidStartCallback([session = GRefPtr<WebKitNetworkSession> { webView->priv->networkSession }, download = download.get()](auto* downloadProxy) {
		4540	#else
4417	downloadProxy.setDidStartCallback([context = GRefPtr<WebKitWebContext> { webView->priv->context }, download = download.get()](auto* downloadProxy) {	4541	downloadProxy.setDidStartCallback([context = GRefPtr<WebKitWebContext> { webView->priv->context }, download = download.get()](auto* downloadProxy) {
		4542	#endif
4418	if (!downloadProxy)	4543	if (!downloadProxy)
4419	return;	4544	return;
4420		4545
4421	webkitDownloadStarted(download);	4546	webkitDownloadStarted(download);
		4547	#if ENABLE(2022_GLIB_API)
		4548	webkitNetworkSessionDownloadStarted(session.get(), download);
		4549	#else
4422	webkitWebContextDownloadStarted(context.get(), download);	4550	webkitWebContextDownloadStarted(context.get(), download);
		4551	#endif
4423	});	4552	});
4424		4553
4425	return download.leakRef();	4554	return download.leakRef();

Lines 54-59 a/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in +11 lines
54	#include <@API_INCLUDE_PREFIX@/WebKitWebsitePolicies.h>	54	#include <@API_INCLUDE_PREFIX@/WebKitWebsitePolicies.h>
55	#include <@API_INCLUDE_PREFIX@/WebKitWindowProperties.h>	55	#include <@API_INCLUDE_PREFIX@/WebKitWindowProperties.h>
56		56
		57	#if ENABLE(2022_GLIB_API)
		58	#include <@API_INCLUDE_PREFIX@/WebKitNetworkSession.h>
		59	#endif
		60
57	#if PLATFORM(GTK)	61	#if PLATFORM(GTK)
58	#include <JavaScriptCore/JSBase.h>	62	#include <JavaScriptCore/JSBase.h>
59	#include <webkit/WebKitColorChooserRequest.h>	63	#include <webkit/WebKitColorChooserRequest.h>
Lines 432-439 WEBKIT_API WebKitWebViewBackend * a/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in_sec2
432	webkit_web_view_get_backend (WebKitWebView *web_view);	436	webkit_web_view_get_backend (WebKitWebView *web_view);
433	#endif	437	#endif
434		438
		439	#if !ENABLE(2022_GLIB_API)
435	WEBKIT_API gboolean	440	WEBKIT_API gboolean
436	webkit_web_view_is_ephemeral (WebKitWebView *web_view);	441	webkit_web_view_is_ephemeral (WebKitWebView *web_view);
		442	#endif
437		443
438	WEBKIT_API gboolean	444	WEBKIT_API gboolean
439	webkit_web_view_is_controlled_by_automation (WebKitWebView *web_view);	445	webkit_web_view_is_controlled_by_automation (WebKitWebView *web_view);
Lines 441-448 webkit_web_view_is_controlled_by_automation (WebKitWebView a/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in_sec3
441	WEBKIT_API WebKitAutomationBrowsingContextPresentation	447	WEBKIT_API WebKitAutomationBrowsingContextPresentation
442	webkit_web_view_get_automation_presentation_type (WebKitWebView *web_view);	448	webkit_web_view_get_automation_presentation_type (WebKitWebView *web_view);
443		449
		450	#if ENABLE(2022_GLIB_API)
		451	WEBKIT_API WebKitNetworkSession *
		452	webkit_web_view_get_network_session (WebKitWebView *web_view);
		453	#else
444	WEBKIT_API WebKitWebsiteDataManager *	454	WEBKIT_API WebKitWebsiteDataManager *
445	webkit_web_view_get_website_data_manager (WebKitWebView *web_view);	455	webkit_web_view_get_website_data_manager (WebKitWebView *web_view);
		456	#endif
446		457
447	WEBKIT_API WebKitWebContext *	458	WEBKIT_API WebKitWebContext *
448	webkit_web_view_get_context (WebKitWebView *web_view);	459	webkit_web_view_get_context (WebKitWebView *web_view);

Lines 21-26 a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp -6 / +107 lines
21	#include "WebKitWebsiteDataManager.h"	21	#include "WebKitWebsiteDataManager.h"
22		22
23	#include "WebKitCookieManagerPrivate.h"	23	#include "WebKitCookieManagerPrivate.h"
		24	#include "WebKitFaviconDatabasePrivate.h"
24	#include "WebKitInitialize.h"	25	#include "WebKitInitialize.h"
25	#include "WebKitMemoryPressureSettings.h"	26	#include "WebKitMemoryPressureSettings.h"
26	#include "WebKitMemoryPressureSettingsPrivate.h"	27	#include "WebKitMemoryPressureSettingsPrivate.h"
Lines 94-104 struct _WebKitWebsiteDataManagerPrivate { a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec2
94	GUniquePtr<char> baseDataDirectory;	95	GUniquePtr<char> baseDataDirectory;
95	GUniquePtr<char> baseCacheDirectory;	96	GUniquePtr<char> baseCacheDirectory;
96		97
		98	#if ENABLE(2022_GLIB_API)
		99	GRefPtr<WebKitFaviconDatabase> faviconDatabase;
		100	#endif
		101
		102	#if !ENABLE(2022_GLIB_API)
97	WebKitTLSErrorsPolicy tlsErrorsPolicy;	103	WebKitTLSErrorsPolicy tlsErrorsPolicy;
98		104
99	GRefPtr<WebKitCookieManager> cookieManager;	105	GRefPtr<WebKitCookieManager> cookieManager;
100		106
101	#if !ENABLE(2022_GLIB_API)
102	// These manual directory overrides are deprecated. Please don't add more.	107	// These manual directory overrides are deprecated. Please don't add more.
103	GUniquePtr<char> localStorageDirectory;	108	GUniquePtr<char> localStorageDirectory;
104	GUniquePtr<char> diskCacheDirectory;	109	GUniquePtr<char> diskCacheDirectory;
Lines 217-228 static void webkitWebsiteDataManagerSetProperty(GObject* object, guint propID, c a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec3
217	}	222	}
218	}	223	}
219		224
		225	#if !ENABLE(2022_GLIB_API)
220	static void webkitWebsiteDataManagerConstructed(GObject* object)	226	static void webkitWebsiteDataManagerConstructed(GObject* object)
221	{	227	{
222	G_OBJECT_CLASS(webkit_website_data_manager_parent_class)->constructed(object);	228	G_OBJECT_CLASS(webkit_website_data_manager_parent_class)->constructed(object);
223		229
224	WebKitWebsiteDataManagerPrivate* priv = WEBKIT_WEBSITE_DATA_MANAGER(object)->priv;	230	WebKitWebsiteDataManagerPrivate* priv = WEBKIT_WEBSITE_DATA_MANAGER(object)->priv;
225	#if !ENABLE(2022_GLIB_API)
226	if (priv->baseDataDirectory) {	231	if (priv->baseDataDirectory) {
227	if (!priv->localStorageDirectory)	232	if (!priv->localStorageDirectory)
228	priv->localStorageDirectory.reset(g_build_filename(priv->baseDataDirectory.get(), "localstorage", nullptr));	233	priv->localStorageDirectory.reset(g_build_filename(priv->baseDataDirectory.get(), "localstorage", nullptr));
Lines 246-267 static void webkitWebsiteDataManagerConstructed(GObject* object) a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec4
246	if (!priv->domCacheDirectory)	251	if (!priv->domCacheDirectory)
247	priv->domCacheDirectory.reset(g_build_filename(priv->baseCacheDirectory.get(), "CacheStorage", nullptr));	252	priv->domCacheDirectory.reset(g_build_filename(priv->baseCacheDirectory.get(), "CacheStorage", nullptr));
248	}	253	}
249	#endif
250		254
251	priv->tlsErrorsPolicy = WEBKIT_TLS_ERRORS_POLICY_FAIL;	255	priv->tlsErrorsPolicy = WEBKIT_TLS_ERRORS_POLICY_FAIL;
252	if (priv->websiteDataStore)	256	if (priv->websiteDataStore)
253	priv->websiteDataStore->setIgnoreTLSErrors(false);	257	priv->websiteDataStore->setIgnoreTLSErrors(false);
254	}	258	}
		259	#endif
255		260
256	static void webkit_website_data_manager_class_init(WebKitWebsiteDataManagerClass* findClass)	261	static void webkit_website_data_manager_class_init(WebKitWebsiteDataManagerClass* findClass)
257	{	262	{
258	webkitInitialize();	263	webkitInitialize();
259		264
260	GObjectClass* gObjectClass = G_OBJECT_CLASS(findClass);	265	GObjectClass* gObjectClass = G_OBJECT_CLASS(findClass);
261
262	gObjectClass->get_property = webkitWebsiteDataManagerGetProperty;	266	gObjectClass->get_property = webkitWebsiteDataManagerGetProperty;
263	gObjectClass->set_property = webkitWebsiteDataManagerSetProperty;	267	gObjectClass->set_property = webkitWebsiteDataManagerSetProperty;
		268	#if !ENABLE(2022_GLIB_API)
264	gObjectClass->constructed = webkitWebsiteDataManagerConstructed;	269	gObjectClass->constructed = webkitWebsiteDataManagerConstructed;
		270	#endif
265		271
266	/**	272	/**
267	* WebKitWebsiteDataManager:base-data-directory:	273	* WebKitWebsiteDataManager:base-data-directory:
Lines 505-516 WebKit::WebsiteDataStore& webkitWebsiteDataManagerGetDataStore(WebKitWebsiteData a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec5
505	configuration->setCacheStorageDirectory(FileSystem::stringFromFileSystemRepresentation(priv->domCacheDirectory.get()));	511	configuration->setCacheStorageDirectory(FileSystem::stringFromFileSystemRepresentation(priv->domCacheDirectory.get()));
506	#endif	512	#endif
507	priv->websiteDataStore = WebKit::WebsiteDataStore::create(WTFMove(configuration), PAL::SessionID::generatePersistentSessionID());	513	priv->websiteDataStore = WebKit::WebsiteDataStore::create(WTFMove(configuration), PAL::SessionID::generatePersistentSessionID());
		514	#if !ENABLE(2022_GLIB_API)
508	priv->websiteDataStore->setIgnoreTLSErrors(priv->tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_IGNORE);	515	priv->websiteDataStore->setIgnoreTLSErrors(priv->tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		516	#endif
509	}	517	}
510		518
511	return *priv->websiteDataStore;	519	return *priv->websiteDataStore;
512	}	520	}
513		521
		522	#if ENABLE(2022_GLIB_API)
		523	WebKitWebsiteDataManager* webkitWebsiteDataManagerCreate(GUniquePtr<char>&& baseDataDirectory, GUniquePtr<char>&& baseCacheDirectory)
		524	{
		525	auto* manager = WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, nullptr));
		526	manager->priv->baseDataDirectory = WTFMove(baseDataDirectory);
		527	manager->priv->baseCacheDirectory = WTFMove(baseCacheDirectory);
		528	return manager;
		529	}
		530	#else
514	/**	531	/**
515	* webkit_website_data_manager_new:	532	* webkit_website_data_manager_new:
516	* @first_option_name: name of the first option to set	533	* @first_option_name: name of the first option to set
Lines 549-554 WebKitWebsiteDataManager* webkit_website_data_manager_new_ephemeral() a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec6
549	{	566	{
550	return WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, "is-ephemeral", TRUE, nullptr));	567	return WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, "is-ephemeral", TRUE, nullptr));
551	}	568	}
		569	#endif
552		570
553	/**	571	/**
554	* webkit_website_data_manager_is_ephemeral:	572	* webkit_website_data_manager_is_ephemeral:
Lines 838-844 const gchar* webkit_website_data_manager_get_dom_cache_directory(WebKitWebsiteDa a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec7
838	priv->domCacheDirectory.reset(g_strdup(WebKit::WebsiteDataStore::defaultCacheStorageDirectory().utf8().data()));	856	priv->domCacheDirectory.reset(g_strdup(WebKit::WebsiteDataStore::defaultCacheStorageDirectory().utf8().data()));
839	return priv->domCacheDirectory.get();	857	return priv->domCacheDirectory.get();
840	}	858	}
841	#endif
842		859
843	/**	860	/**
844	* webkit_website_data_manager_get_cookie_manager:	861	* webkit_website_data_manager_get_cookie_manager:
Lines 1015-1020 void webkit_website_data_manager_set_network_proxy_settings(WebKitWebsiteDataMan a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec8
1015	break;	1032	break;
1016	}	1033	}
1017	}	1034	}
		1035	#endif
		1036
		1037	#if ENABLE(2022_GLIB_API)
		1038	static String webkitWebsiteDataManagerGetFaviconDatabasePath(WebKitWebsiteDataManager* manager)
		1039	{
		1040	if (webkit_website_data_manager_is_ephemeral(manager))
		1041	return { };
		1042
		1043	if (manager->priv->baseCacheDirectory)
		1044	return FileSystem::pathByAppendingComponents(FileSystem::stringFromFileSystemRepresentation(manager->priv->baseCacheDirectory.get()), { "icondatabase"_s, "WebpageIcons.db"_s });
		1045
		1046	auto programName = []() -> String {
		1047	if (auto* prgname = g_get_prgname())
		1048	return String::fromUTF8(prgname);
		1049	#if PLATFORM(GTK)
		1050	return "webkitgtk"_s;
		1051	#elif PLATFORM(WPE)
		1052	return "wpe"_s;
		1053	#endif
		1054	RELEASE_ASSERT_NOT_REACHED();
		1055	};
		1056	return FileSystem::pathByAppendingComponents(FileSystem::userCacheDirectory(), { programName(), "icondatabase"_s, "WebpageIcons.db"_s });
		1057	}
		1058
		1059	/**
		1060	* webkit_website_data_manager_set_favicons_enabled_
		1061	* @manager: a #WebKitWebsiteDataManager
		1062	* @enabled: value to set
		1063	*
		1064	* Enable website icons
		1065	*
		1066	* Since: 2.40
		1067	*/
		1068	void webkit_website_data_manager_set_favicons_enabled(WebKitWebsiteDataManager* manager, gboolean enabled)
		1069	{
		1070	g_return_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
		1071
		1072	if (enabled) {
		1073	if (!manager->priv->faviconDatabase)
		1074	manager->priv->faviconDatabase = webkitFaviconDatabaseCreate();
		1075	auto path = webkitWebsiteDataManagerGetFaviconDatabasePath(manager);
		1076	webkitFaviconDatabaseOpen(manager->priv->faviconDatabase.get(), path, path.isNull());
		1077	} else if (manager->priv->faviconDatabase) {
		1078	webkitFaviconDatabaseClose(manager->priv->faviconDatabase.get());
		1079	manager->priv->faviconDatabase = nullptr;
		1080	}
		1081	}
		1082
		1083	/**
		1084	* webkit_website_data_manager_get_favicons_enabled:
		1085	* @manager: a #WebKitWebsiteDataManager
		1086	*
		1087	* Get whether website icons are enabled.
		1088	*
		1089	* Returns: %TRUE if website icons are enabled, or %FALSE otherwise.
		1090	*
		1091	* Since: 2.40
		1092	*/
		1093	gboolean webkit_website_data_manager_get_favicons_enabled(WebKitWebsiteDataManager* manager)
		1094	{
		1095	g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), FALSE);
		1096
		1097	return !!manager->priv->faviconDatabase;
		1098	}
1099
1100	/**
1101	* webkit_website_data_manager_get_favicon_database:
1102	* @manager: a #WebKitWebsiteDataManager
1103	*
1104	* Get the #WebKitFaviconDatabase of @manager.
1105	*
1106	* Returns: (transfer none) (nullable): a #WebKitFaviconDatabase, or %NULL if website icons are disabled
1107	*
1108	* Since: 2.40
1109	*/
1110	WebKitFaviconDatabase* webkit_website_data_manager_get_favicon_database(WebKitWebsiteDataManager* manager)
1111	{
1112	g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
1113
1114	return manager->priv->faviconDatabase.get();
1115	}
1116	#endif
1018		1117
1019	static OptionSet<WebsiteDataType> toWebsiteDataTypes(WebKitWebsiteDataTypes types)	1118	static OptionSet<WebsiteDataType> toWebsiteDataTypes(WebKitWebsiteDataTypes types)
1020	{	1119	{
Lines 1247-1252 struct _WebKitITPFirstParty { a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec9
1247	int referenceCount { 1 };	1346	int referenceCount { 1 };
1248	};	1347	};
1249		1348
		1349	#if !ENABLE(2022_GLIB_API)
1250	/**	1350	/**
1251	* webkit_website_data_manager_set_memory_pressure_settings:	1351	* webkit_website_data_manager_set_memory_pressure_settings:
1252	* @settings: a WebKitMemoryPressureSettings.	1352	* @settings: a WebKitMemoryPressureSettings.
Lines 1272-1277 void webkit_website_data_manager_set_memory_pressure_settings(WebKitMemoryPressu a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec10
1272	std::optional<MemoryPressureHandler::Configuration> config = settings ? std::make_optional(webkitMemoryPressureSettingsGetMemoryPressureHandlerConfiguration(settings)) : std::nullopt;	1372	std::optional<MemoryPressureHandler::Configuration> config = settings ? std::make_optional(webkitMemoryPressureSettingsGetMemoryPressureHandlerConfiguration(settings)) : std::nullopt;
1273	WebProcessPool::setNetworkProcessMemoryPressureHandlerConfiguration(config);	1373	WebProcessPool::setNetworkProcessMemoryPressureHandlerConfiguration(config);
1274	}	1374	}
		1375	#endif
1275		1376
1276	G_DEFINE_BOXED_TYPE(WebKitITPFirstParty, webkit_itp_first_party, webkit_itp_first_party_ref, webkit_itp_first_party_unref)	1377	G_DEFINE_BOXED_TYPE(WebKitITPFirstParty, webkit_itp_first_party, webkit_itp_first_party_ref, webkit_itp_first_party_unref)
1277		1378
Lines 1410-1416 struct _WebKitITPThirdParty { a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp_sec11
1410		1511
1411	G_DEFINE_BOXED_TYPE(WebKitITPThirdParty, webkit_itp_third_party, webkit_itp_third_party_ref, webkit_itp_third_party_unref)	1512	G_DEFINE_BOXED_TYPE(WebKitITPThirdParty, webkit_itp_third_party, webkit_itp_third_party_ref, webkit_itp_third_party_unref)
1412		1513
1413	static WebKitITPThirdParty* webkitITPThirdPartyCreate(WebResourceLoadStatisticsStore::ThirdPartyData&& data)	1514	WebKitITPThirdParty* webkitITPThirdPartyCreate(WebResourceLoadStatisticsStore::ThirdPartyData&& data)
1414	{	1515	{
1415	auto* thirdParty = static_cast<WebKitITPThirdParty*>(fastMalloc(sizeof(WebKitITPThirdParty)));	1516	auto* thirdParty = static_cast<WebKitITPThirdParty*>(fastMalloc(sizeof(WebKitITPThirdParty)));
1416	new (thirdParty) WebKitITPThirdParty(WTFMove(data));	1517	new (thirdParty) WebKitITPThirdParty(WTFMove(data));

Lines 25-30 a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in -1 / +20 lines
25	#include <gio/gio.h>	25	#include <gio/gio.h>
26	#include <@API_INCLUDE_PREFIX@/WebKitCookieManager.h>	26	#include <@API_INCLUDE_PREFIX@/WebKitCookieManager.h>
27	#include <@API_INCLUDE_PREFIX@/WebKitDefines.h>	27	#include <@API_INCLUDE_PREFIX@/WebKitDefines.h>
		28	#if ENABLE(2022_GLIB_API)
		29	#include <@API_INCLUDE_PREFIX@/WebKitFaviconDatabase.h>
		30	#endif
28	#include <@API_INCLUDE_PREFIX@/WebKitMemoryPressureSettings.h>	31	#include <@API_INCLUDE_PREFIX@/WebKitMemoryPressureSettings.h>
29	#include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>	32	#include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>
30	#include <@API_INCLUDE_PREFIX@/WebKitWebsiteData.h>	33	#include <@API_INCLUDE_PREFIX@/WebKitWebsiteData.h>
Lines 77-87 struct _WebKitWebsiteDataManagerClass { a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in_sec2
77	WEBKIT_API GType	80	WEBKIT_API GType
78	webkit_website_data_manager_get_type (void);	81	webkit_website_data_manager_get_type (void);
79		82
		83	#if !ENABLE(2022_GLIB_API)
80	WEBKIT_API WebKitWebsiteDataManager *	84	WEBKIT_API WebKitWebsiteDataManager *
81	webkit_website_data_manager_new (const gchar *first_option_name,	85	webkit_website_data_manager_new (const gchar *first_option_name,
82	...);	86	...);
83	WEBKIT_API WebKitWebsiteDataManager *	87	WEBKIT_API WebKitWebsiteDataManager *
84	webkit_website_data_manager_new_ephemeral (void);	88	webkit_website_data_manager_new_ephemeral (void);
		89	#endif
85		90
86	WEBKIT_API gboolean	91	WEBKIT_API gboolean
87	webkit_website_data_manager_is_ephemeral (WebKitWebsiteDataManager* manager);	92	webkit_website_data_manager_is_ephemeral (WebKitWebsiteDataManager* manager);
Lines 92-97 webkit_website_data_manager_get_base_data_directory (WebKitWeb a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in_sec3
92	WEBKIT_API const gchar *	97	WEBKIT_API const gchar *
93	webkit_website_data_manager_get_base_cache_directory (WebKitWebsiteDataManager *manager);	98	webkit_website_data_manager_get_base_cache_directory (WebKitWebsiteDataManager *manager);
94		99
		100	#if ENABLE(2022_GLIB_API)
		101	WEBKIT_API void
		102	webkit_website_data_manager_set_favicons_enabled (WebKitWebsiteDataManager *manager,
		103	gboolean enabled);
		104
		105	WEBKIT_API gboolean
		106	webkit_website_data_manager_get_favicons_enabled (WebKitWebsiteDataManager *manager);
		107
		108	WEBKIT_API WebKitFaviconDatabase *
		109	webkit_website_data_manager_get_favicon_database (WebKitWebsiteDataManager *manager);
		110	#endif
		111
95	#if !ENABLE(2022_GLIB_API)	112	#if !ENABLE(2022_GLIB_API)
96	WEBKIT_DEPRECATED const gchar *	113	WEBKIT_DEPRECATED const gchar *
97	webkit_website_data_manager_get_local_storage_directory (WebKitWebsiteDataManager *manager);	114	webkit_website_data_manager_get_local_storage_directory (WebKitWebsiteDataManager *manager);
Lines 119-125 webkit_website_data_manager_get_service_worker_registrations_directory(WebKitWeb a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in_sec4
119		136
120	WEBKIT_DEPRECATED const gchar *	137	WEBKIT_DEPRECATED const gchar *
121	webkit_website_data_manager_get_dom_cache_directory (WebKitWebsiteDataManager *manager);	138	webkit_website_data_manager_get_dom_cache_directory (WebKitWebsiteDataManager *manager);
122	#endif
123		139
124	WEBKIT_API WebKitCookieManager *	140	WEBKIT_API WebKitCookieManager *
125	webkit_website_data_manager_get_cookie_manager (WebKitWebsiteDataManager *manager);	141	webkit_website_data_manager_get_cookie_manager (WebKitWebsiteDataManager *manager);
Lines 149-154 WEBKIT_API void a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in_sec5
149	webkit_website_data_manager_set_network_proxy_settings (WebKitWebsiteDataManager *manager,	165	webkit_website_data_manager_set_network_proxy_settings (WebKitWebsiteDataManager *manager,
150	WebKitNetworkProxyMode proxy_mode,	166	WebKitNetworkProxyMode proxy_mode,
151	WebKitNetworkProxySettings *proxy_settings);	167	WebKitNetworkProxySettings *proxy_settings);
		168	#endif
152		169
153	WEBKIT_API void	170	WEBKIT_API void
154	webkit_website_data_manager_fetch (WebKitWebsiteDataManager *manager,	171	webkit_website_data_manager_fetch (WebKitWebsiteDataManager *manager,
Lines 186-193 webkit_website_data_manager_clear_finish (WebKitWe a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in_sec6
186	GAsyncResult *result,	203	GAsyncResult *result,
187	GError **error);	204	GError **error);
188		205
		206	#if !ENABLE(2022_GLIB_API)
189	WEBKIT_API void	207	WEBKIT_API void
190	webkit_website_data_manager_set_memory_pressure_settings (WebKitMemoryPressureSettings *settings);	208	webkit_website_data_manager_set_memory_pressure_settings (WebKitMemoryPressureSettings *settings);
		209	#endif
191		210
192		211
193	#define WEBKIT_TYPE_ITP_FIRST_PARTY (webkit_itp_first_party_get_type())	212	#define WEBKIT_TYPE_ITP_FIRST_PARTY (webkit_itp_first_party_get_type())

Lines 19-24 a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManagerPrivate.h_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManagerPrivate.h +6 lines
19		19
20	#pragma once	20	#pragma once
21		21
		22	#include "WebResourceLoadStatisticsStore.h"
22	#include "WebsiteDataStore.h"	23	#include "WebsiteDataStore.h"
		24	#include <wtf/glib/GUniquePtr.h>
23		25
		26	#if ENABLE(2022_GLIB_API)
		27	WebKitWebsiteDataManager* webkitWebsiteDataManagerCreate(GUniquePtr<char>&&, GUniquePtr<char>&&);
		28	#endif
24	WebKit::WebsiteDataStore& webkitWebsiteDataManagerGetDataStore(WebKitWebsiteDataManager*);	29	WebKit::WebsiteDataStore& webkitWebsiteDataManagerGetDataStore(WebKitWebsiteDataManager*);
		30	WebKitITPThirdParty* webkitITPThirdPartyCreate(WebKit::WebResourceLoadStatisticsStore::ThirdPartyData&&);

Lines 76-81 a/Source/WebKit/UIProcess/API/glib/webkit.h.in_sec1
- a/Source/WebKit/UIProcess/API/glib/webkit.h.in +3 lines
76	#include <@API_INCLUDE_PREFIX@/WebKitNavigationAction.h>	76	#include <@API_INCLUDE_PREFIX@/WebKitNavigationAction.h>
77	#include <@API_INCLUDE_PREFIX@/WebKitNavigationPolicyDecision.h>	77	#include <@API_INCLUDE_PREFIX@/WebKitNavigationPolicyDecision.h>
78	#include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>	78	#include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>
		79	#if ENABLE(2022_GLIB_API)
		80	#include <@API_INCLUDE_PREFIX@/WebKitNetworkSession.h>
		81	#endif
79	#include <@API_INCLUDE_PREFIX@/WebKitNotification.h>	82	#include <@API_INCLUDE_PREFIX@/WebKitNotification.h>
80	#include <@API_INCLUDE_PREFIX@/WebKitNotificationPermissionRequest.h>	83	#include <@API_INCLUDE_PREFIX@/WebKitNotificationPermissionRequest.h>
81	#include <@API_INCLUDE_PREFIX@/WebKitOptionMenu.h>	84	#include <@API_INCLUDE_PREFIX@/WebKitOptionMenu.h>



    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));
}




    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));
}

Lines 253-259 SOAuthorizationCoordinator& WebsiteDataStore::soAuthorizationCoordinator(const W a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp_sec1
- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp -1 / +1 lines
253		253
254	static Ref<NetworkProcessProxy> networkProcessForSession(PAL::SessionID sessionID)	254	static Ref<NetworkProcessProxy> networkProcessForSession(PAL::SessionID sessionID)
255	{	255	{
256	#if PLATFORM(GTK) \|\| PLATFORM(WPE)	256	#if ((PLATFORM(GTK) \|\| PLATFORM(WPE)) && !ENABLE(2022_GLIB_API))
257	if (sessionID.isEphemeral()) {	257	if (sessionID.isEphemeral()) {
258	// Reuse a previous persistent session network process for ephemeral sessions.	258	// Reuse a previous persistent session network process for ephemeral sessions.
259	for (auto* dataStore : allDataStores().values()) {	259	for (auto* dataStore : allDataStores().values()) {

Lines 218-224 static void tlsErrorsDialogResponse(GtkWidget *dialog, gint response, BrowserTab a/Tools/MiniBrowser/gtk/BrowserTab.c_sec1
- a/Tools/MiniBrowser/gtk/BrowserTab.c +4 lines
218	GTlsCertificate certificate = (GTlsCertificate )g_object_get_data(G_OBJECT(dialog), "certificate");	218	GTlsCertificate certificate = (GTlsCertificate )g_object_get_data(G_OBJECT(dialog), "certificate");
219	#if SOUP_CHECK_VERSION(2, 91, 0)	219	#if SOUP_CHECK_VERSION(2, 91, 0)
220	GUri *uri = g_uri_parse(failingURI, SOUP_HTTP_URI_FLAGS, NULL);	220	GUri *uri = g_uri_parse(failingURI, SOUP_HTTP_URI_FLAGS, NULL);
		221	#if GTK_CHECK_VERSION(3, 98, 5)
		222	webkit_network_session_allow_tls_certificate_for_host(webkit_web_view_get_network_session(tab->webView), certificate, g_uri_get_host(uri));
		223	#else
221	webkit_web_context_allow_tls_certificate_for_host(webkit_web_view_get_context(tab->webView), certificate, g_uri_get_host(uri));	224	webkit_web_context_allow_tls_certificate_for_host(webkit_web_view_get_context(tab->webView), certificate, g_uri_get_host(uri));
		225	#endif
222	g_uri_unref(uri);	226	g_uri_unref(uri);
223	#else	227	#else
224	SoupURI *uri = soup_uri_new(failingURI);	228	SoupURI *uri = soup_uri_new(failingURI);

Lines 40-45 struct _BrowserWindow { a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec1
- a/Tools/MiniBrowser/gtk/BrowserWindow.c -2 / +67 lines
40	GtkApplicationWindow parent;	40	GtkApplicationWindow parent;
41		41
42	WebKitWebContext *webContext;	42	WebKitWebContext *webContext;
		43	#if GTK_CHECK_VERSION(3, 98, 0)
		44	WebKitNetworkSession *networkSession;
		45	#endif
43		46
44	GtkWidget *mainBox;	47	GtkWidget *mainBox;
45	GtkWidget *toolbar;	48	GtkWidget *toolbar;
Lines 159-165 static void webViewTitleChanged(WebKitWebView webView, GParamSpec pspec, Brows a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec2
159	char *privateTitle = NULL;	162	char *privateTitle = NULL;
160	if (webkit_web_view_is_controlled_by_automation(webView))	163	if (webkit_web_view_is_controlled_by_automation(webView))
161	privateTitle = g_strdup_printf("[Automation] %s", title);	164	privateTitle = g_strdup_printf("[Automation] %s", title);
		165	#if GTK_CHECK_VERSION(3, 98, 0)
		166	else if (webkit_network_session_is_ephemeral(webkit_web_view_get_network_session(webView)))
		167	#else
162	else if (webkit_web_view_is_ephemeral(webView))	168	else if (webkit_web_view_is_ephemeral(webView))
		169	#endif
163	privateTitle = g_strdup_printf("[Private] %s", title);	170	privateTitle = g_strdup_printf("[Private] %s", title);
164	gtk_window_set_title(GTK_WINDOW(window), privateTitle ? privateTitle : title);	171	gtk_window_set_title(GTK_WINDOW(window), privateTitle ? privateTitle : title);
165	g_free(privateTitle);	172	g_free(privateTitle);
Lines 185-193 static void webViewLoadProgressChanged(WebKitWebView webView, GParamSpec pspec a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec3
185	}	192	}
186	}	193	}
187		194
		195	#if !GTK_CHECK_VERSION(3, 98, 0)
188	static void downloadStarted(WebKitWebContext webContext, WebKitDownload download, BrowserWindow *window)	196	static void downloadStarted(WebKitWebContext webContext, WebKitDownload download, BrowserWindow *window)
189	{	197	{
190	#if !GTK_CHECK_VERSION(3, 98, 0)
191	if (!window->downloadsBar) {	198	if (!window->downloadsBar) {
192	window->downloadsBar = browser_downloads_bar_new();	199	window->downloadsBar = browser_downloads_bar_new();
193	gtk_box_pack_start(GTK_BOX(window->mainBox), window->downloadsBar, FALSE, FALSE, 0);	200	gtk_box_pack_start(GTK_BOX(window->mainBox), window->downloadsBar, FALSE, FALSE, 0);
Lines 196-203 static void downloadStarted(WebKitWebContext webContext, WebKitDownload downlo a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec4
196	gtk_widget_show(window->downloadsBar);	203	gtk_widget_show(window->downloadsBar);
197	}	204	}
198	browser_downloads_bar_add_download(BROWSER_DOWNLOADS_BAR(window->downloadsBar), download);	205	browser_downloads_bar_add_download(BROWSER_DOWNLOADS_BAR(window->downloadsBar), download);
199	#endif
200	}	206	}
		207	#endif
201		208
202	static void browserWindowHistoryItemActivated(BrowserWindow window, GVariant parameter, GAction *action)	209	static void browserWindowHistoryItemActivated(BrowserWindow window, GVariant parameter, GAction *action)
203	{	210	{
Lines 458-464 static GtkWidget webViewCreate(WebKitWebView webView, WebKitNavigationAction * a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec5
458	WebKitWebView *newWebView = WEBKIT_WEB_VIEW(webkit_web_view_new_with_related_view(webView));	465	WebKitWebView *newWebView = WEBKIT_WEB_VIEW(webkit_web_view_new_with_related_view(webView));
459	webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));	466	webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));
460		467
		468	#if GTK_CHECK_VERSION(3, 98, 0)
		469	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext, window->networkSession);
		470	#else
461	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);	471	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);
		472	#endif
462	gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));	473	gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));
463	browser_window_append_view(BROWSER_WINDOW(newWindow), newWebView);	474	browser_window_append_view(BROWSER_WINDOW(newWindow), newWebView);
464	gtk_widget_grab_focus(GTK_WIDGET(newWebView));	475	gtk_widget_grab_focus(GTK_WIDGET(newWebView));
Lines 504-509 static gboolean webViewDecidePolicy(WebKitWebView *webView, WebKitPolicyDecision a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec6
504	/* Opening a new tab if link clicked with the middle button. */	515	/* Opening a new tab if link clicked with the middle button. */
505	WebKitWebView *newWebView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,	516	WebKitWebView *newWebView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
506	"web-context", webkit_web_view_get_context(webView),	517	"web-context", webkit_web_view_get_context(webView),
		518	#if GTK_CHECK_VERSION(3, 98, 0)
		519	"network-session", webkit_web_view_get_network_session(webView),
		520	#endif
507	"settings", webkit_web_view_get_settings(webView),	521	"settings", webkit_web_view_get_settings(webView),
508	"user-content-manager", webkit_web_view_get_user_content_manager(webView),	522	"user-content-manager", webkit_web_view_get_user_content_manager(webView),
509	"is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),	523	"is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),
Lines 756-761 static void newTabCallback(GSimpleAction action, GVariant parameter, gpointer a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec7
756		770
757	browser_window_append_view(window, WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,	771	browser_window_append_view(window, WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
758	"web-context", webkit_web_view_get_context(webView),	772	"web-context", webkit_web_view_get_context(webView),
		773	#if GTK_CHECK_VERSION(3, 98, 0)
		774	"network-session", window->networkSession,
		775	#endif
759	"settings", webkit_web_view_get_settings(webView),	776	"settings", webkit_web_view_get_settings(webView),
760	"user-content-manager", webkit_web_view_get_user_content_manager(webView),	777	"user-content-manager", webkit_web_view_get_user_content_manager(webView),
761	"is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),	778	"is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),
Lines 774-788 static void openPrivateWindow(GSimpleAction action, GVariant parameter, gpoint a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec8
774	{	791	{
775	BrowserWindow *window = BROWSER_WINDOW(userData);	792	BrowserWindow *window = BROWSER_WINDOW(userData);
776	WebKitWebView *webView = browser_tab_get_web_view(window->activeTab);	793	WebKitWebView *webView = browser_tab_get_web_view(window->activeTab);
		794
		795	#if GTK_CHECK_VERSION(3, 98, 0)
		796	WebKitNetworkSession *networkSession = NULL;
		797	if (!webkit_web_view_is_controlled_by_automation(webView)) {
		798	networkSession = webkit_network_session_new_ephemeral();
		799	webkit_website_data_manager_set_favicons_enabled(webkit_network_session_get_website_data_manager(networkSession), TRUE);
		800	webkit_network_session_set_tls_errors_policy(networkSession, webkit_network_session_get_tls_errors_policy(window->networkSession));
		801	// FIXME: we need public api to get proxy settings.
		802	}
		803	#endif
777	WebKitWebView *newWebView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,	804	WebKitWebView *newWebView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
778	"web-context", webkit_web_view_get_context(webView),	805	"web-context", webkit_web_view_get_context(webView),
779	"settings", webkit_web_view_get_settings(webView),	806	"settings", webkit_web_view_get_settings(webView),
780	"user-content-manager", webkit_web_view_get_user_content_manager(webView),	807	"user-content-manager", webkit_web_view_get_user_content_manager(webView),
		808	#if GTK_CHECK_VERSION(3, 98, 0)
		809	"network-session", networkSession,
		810	#else
781	"is-ephemeral", TRUE,	811	"is-ephemeral", TRUE,
		812	#endif
782	"is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),	813	"is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),
783	"website-policies", webkit_web_view_get_website_policies(webView),	814	"website-policies", webkit_web_view_get_website_policies(webView),
784	NULL));	815	NULL));
		816	#if GTK_CHECK_VERSION(3, 98, 0)
		817	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext, networkSession);
		818	g_clear_object(&networkSession);
		819	#else
785	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);	820	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);
		821	#endif
786	gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));	822	gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));
787	browser_window_append_view(BROWSER_WINDOW(newWindow), newWebView);	823	browser_window_append_view(BROWSER_WINDOW(newWindow), newWebView);
788	gtk_widget_grab_focus(GTK_WIDGET(newWebView));	824	gtk_widget_grab_focus(GTK_WIDGET(newWebView));
Lines 962-967 static void browserWindowFinalize(GObject *gObject) a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec9
962	g_signal_handlers_disconnect_matched(window->webContext, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, window);	998	g_signal_handlers_disconnect_matched(window->webContext, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, window);
963	g_object_unref(window->webContext);	999	g_object_unref(window->webContext);
964		1000
		1001	#if GTK_CHECK_VERSION(3, 98, 5)
		1002	g_clear_object(&window->networkSession);
		1003	#endif
		1004
965	if (window->favicon) {	1005	if (window->favicon) {
966	g_object_unref(window->favicon);	1006	g_object_unref(window->favicon);
967	window->favicon = NULL;	1007	window->favicon = NULL;
Lines 1461-1467 static void browser_window_class_init(BrowserWindowClass *klass) a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec10
1461	}	1501	}
1462		1502
1463	/* Public API. */	1503	/* Public API. */
		1504	#if GTK_CHECK_VERSION(3, 98, 0)
		1505	GtkWidget browser_window_new(GtkWindow parent, WebKitWebContext webContext, WebKitNetworkSession networkSession)
		1506	#else
1464	GtkWidget browser_window_new(GtkWindow parent, WebKitWebContext *webContext)	1507	GtkWidget browser_window_new(GtkWindow parent, WebKitWebContext *webContext)
		1508	#endif
1465	{	1509	{
1466	g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(webContext), NULL);	1510	g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(webContext), NULL);
1467		1511
Lines 1472-1478 GtkWidget browser_window_new(GtkWindow parent, WebKitWebContext *webContext) a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec11
1472	NULL));	1516	NULL));
1473		1517
1474	window->webContext = g_object_ref(webContext);	1518	window->webContext = g_object_ref(webContext);
		1519	#if GTK_CHECK_VERSION(3, 98, 0)
		1520	window->networkSession = networkSession ? g_object_ref(networkSession) : NULL;
		1521	#else
1475	g_signal_connect(window->webContext, "download-started", G_CALLBACK(downloadStarted), window);	1522	g_signal_connect(window->webContext, "download-started", G_CALLBACK(downloadStarted), window);
		1523	#endif
		1524
1476	if (parent) {	1525	if (parent) {
1477	window->parentWindow = parent;	1526	window->parentWindow = parent;
1478	g_object_add_weak_pointer(G_OBJECT(parent), (gpointer *)&window->parentWindow);	1527	g_object_add_weak_pointer(G_OBJECT(parent), (gpointer *)&window->parentWindow);
Lines 1481-1486 GtkWidget browser_window_new(GtkWindow parent, WebKitWebContext *webContext) a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec12
1481	return GTK_WIDGET(window);	1530	return GTK_WIDGET(window);
1482	}	1531	}
1483		1532
		1533	#if GTK_CHECK_VERSION(3, 98, 0)
		1534	WebKitNetworkSession* browser_window_get_network_session(BrowserWindow *window)
		1535	{
		1536	g_return_val_if_fail(BROWSER_IS_WINDOW(window), NULL);
		1537
		1538	return window->networkSession;
		1539	}
		1540	#endif
		1541
1484	WebKitWebContext browser_window_get_web_context(BrowserWindow window)	1542	WebKitWebContext browser_window_get_web_context(BrowserWindow window)
1485	{	1543	{
1486	g_return_val_if_fail(BROWSER_IS_WINDOW(window), NULL);	1544	g_return_val_if_fail(BROWSER_IS_WINDOW(window), NULL);
Lines 1568-1573 void browser_window_load_session(BrowserWindow window, const char sessionFile) a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec13
1568	if (!webView) {	1626	if (!webView) {
1569	webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,	1627	webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
1570	"web-context", webkit_web_view_get_context(previousWebView),	1628	"web-context", webkit_web_view_get_context(previousWebView),
		1629	#if GTK_CHECK_VERSION(3, 98, 0)
		1630	"network-session", webkit_web_view_get_network_session(previousWebView),
		1631	#endif
1571	"settings", webkit_web_view_get_settings(previousWebView),	1632	"settings", webkit_web_view_get_settings(previousWebView),
1572	"user-content-manager", webkit_web_view_get_user_content_manager(previousWebView),	1633	"user-content-manager", webkit_web_view_get_user_content_manager(previousWebView),
1573	"website-policies", webkit_web_view_get_website_policies(previousWebView),	1634	"website-policies", webkit_web_view_get_website_policies(previousWebView),
Lines 1637-1643 WebKitWebView *browser_window_get_or_create_web_view_for_automation(BrowserWindo a/Tools/MiniBrowser/gtk/BrowserWindow.c_sec14
1637	"is-controlled-by-automation", TRUE,	1698	"is-controlled-by-automation", TRUE,
1638	"website-policies", webkit_web_view_get_website_policies(webView),	1699	"website-policies", webkit_web_view_get_website_policies(webView),
1639	NULL));	1700	NULL));
		1701	#if GTK_CHECK_VERSION(3, 98, 0)
		1702	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext, window->networkSession);
		1703	#else
1640	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);	1704	GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);
		1705	#endif
1641	gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));	1706	gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));
1642	#if !GTK_CHECK_VERSION(3, 98, 0)	1707	#if !GTK_CHECK_VERSION(3, 98, 0)
1643	gtk_window_set_focus_on_map(GTK_WINDOW(newWindow), FALSE);	1708	gtk_window_set_focus_on_map(GTK_WINDOW(newWindow), FALSE);

Lines 50-56 typedef struct _BrowserWindowClass BrowserWindowClass; a/Tools/MiniBrowser/gtk/BrowserWindow.h_sec1
- a/Tools/MiniBrowser/gtk/BrowserWindow.h +5 lines
50		50
51	GType browser_window_get_type(void);	51	GType browser_window_get_type(void);
52		52
		53	#if GTK_CHECK_VERSION(3, 98, 0)
		54	GtkWidget* browser_window_new(GtkWindow, WebKitWebContext, WebKitNetworkSession*);
		55	WebKitNetworkSession* browser_window_get_network_session(BrowserWindow*);
		56	#else
53	GtkWidget* browser_window_new(GtkWindow, WebKitWebContext);	57	GtkWidget* browser_window_new(GtkWindow, WebKitWebContext);
		58	#endif
54	WebKitWebContext* browser_window_get_web_context(BrowserWindow*);	59	WebKitWebContext* browser_window_get_web_context(BrowserWindow*);
55	void browser_window_append_view(BrowserWindow, WebKitWebView);	60	void browser_window_append_view(BrowserWindow, WebKitWebView);
56	void browser_window_load_uri(BrowserWindow, const char uri);	61	void browser_window_load_uri(BrowserWindow, const char uri);

Lines 96-101 static WebKitWebView createBrowserTab(BrowserWindow window, WebKitSettings *we a/Tools/MiniBrowser/gtk/main.c_sec1
- a/Tools/MiniBrowser/gtk/main.c -13 / +89 lines
96	{	96	{
97	WebKitWebView *webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,	97	WebKitWebView *webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
98	"web-context", browser_window_get_web_context(window),	98	"web-context", browser_window_get_web_context(window),
		99	#if GTK_CHECK_VERSION(3, 98, 0)
		100	"network-session", browser_window_get_network_session(window),
		101	#endif
99	"settings", webkitSettings,	102	"settings", webkitSettings,
100	"user-content-manager", userContentManager,	103	"user-content-manager", userContentManager,
101	"is-controlled-by-automation", automationMode,	104	"is-controlled-by-automation", automationMode,
Lines 354-360 static void websiteDataClearedCallback(WebKitWebsiteDataManager *manager, GAsync a/Tools/MiniBrowser/gtk/main.c_sec2
354	webkit_web_view_reload(webkit_uri_scheme_request_get_web_view(dataRequest->request));	357	webkit_web_view_reload(webkit_uri_scheme_request_get_web_view(dataRequest->request));
355	}	358	}
356		359
357	static void aboutDataScriptMessageReceivedCallback(WebKitUserContentManager userContentManager, WebKitJavascriptResult message, WebKitWebContext *webContext)	360	static void aboutDataScriptMessageReceivedCallback(WebKitUserContentManager userContentManager, WebKitJavascriptResult message, WebKitWebsiteDataManager *manager)
358	{	361	{
359	char *messageString = jsc_value_to_string(webkit_javascript_result_get_js_value(message));	362	char *messageString = jsc_value_to_string(webkit_javascript_result_get_js_value(message));
360	char **tokens = g_strsplit(messageString, ":", 3);	363	char **tokens = g_strsplit(messageString, ":", 3);
Lines 373-379 static void aboutDataScriptMessageReceivedCallback(WebKitUserContentManager *use a/Tools/MiniBrowser/gtk/main.c_sec3
373	return;	376	return;
374	}	377	}
375		378
376	WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);
377	guint64 types = g_ascii_strtoull(tokens[1], NULL, 10);	379	guint64 types = g_ascii_strtoull(tokens[1], NULL, 10);
378	if (tokenCount == 2)	380	if (tokenCount == 2)
379	webkit_website_data_manager_clear(manager, types, 0, NULL, (GAsyncReadyCallback)websiteDataClearedCallback, dataRequest);	381	webkit_website_data_manager_clear(manager, types, 0, NULL, (GAsyncReadyCallback)websiteDataClearedCallback, dataRequest);
Lines 475-484 static void gotWebsiteDataCallback(WebKitWebsiteDataManager *manager, GAsyncResu a/Tools/MiniBrowser/gtk/main.c_sec4
475	g_list_free_full(dataList, (GDestroyNotify)webkit_website_data_unref);	477	g_list_free_full(dataList, (GDestroyNotify)webkit_website_data_unref);
476	}	478	}
477		479
478	static void aboutDataHandleRequest(WebKitURISchemeRequest request, WebKitWebContext webContext)	480	static void aboutDataHandleRequest(WebKitURISchemeRequest *request)
479	{	481	{
480	AboutDataRequest *dataRequest = aboutDataRequestNew(request);	482	AboutDataRequest *dataRequest = aboutDataRequestNew(request);
481	WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);	483	WebKitWebView *webView = webkit_uri_scheme_request_get_web_view(request);
		484	#if GTK_CHECK_VERSION(3, 98, 0)
		485	WebKitWebsiteDataManager *manager = webkit_network_session_get_website_data_manager(webkit_web_view_get_network_session(webView));
		486	#else
		487	WebKitWebsiteDataManager *manager = webkit_web_view_get_website_data_manager(webView);
		488	#endif
482	webkit_website_data_manager_fetch(manager, WEBKIT_WEBSITE_DATA_ALL, NULL, (GAsyncReadyCallback)gotWebsiteDataCallback, dataRequest);	489	webkit_website_data_manager_fetch(manager, WEBKIT_WEBSITE_DATA_ALL, NULL, (GAsyncReadyCallback)gotWebsiteDataCallback, dataRequest);
483	}	490	}
484		491
Lines 530-543 static void gotITPSummaryCallback(WebKitWebsiteDataManager *manager, GAsyncResul a/Tools/MiniBrowser/gtk/main.c_sec5
530	aboutITPRequestFree(itpRequest);	537	aboutITPRequestFree(itpRequest);
531	}	538	}
532		539
533	static void aboutITPHandleRequest(WebKitURISchemeRequest request, WebKitWebContext webContext)	540	static void aboutITPHandleRequest(WebKitURISchemeRequest *request)
534	{	541	{
535	AboutITPRequest *itpRequest = aboutITPRequestNew(request);	542	AboutITPRequest *itpRequest = aboutITPRequestNew(request);
536	WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);	543	WebKitWebView *webView = webkit_uri_scheme_request_get_web_view(request);
		544	#if GTK_CHECK_VERSION(3, 98, 0)
		545	WebKitWebsiteDataManager *manager = webkit_network_session_get_website_data_manager(webkit_web_view_get_network_session(webView));
		546	#else
		547	WebKitWebsiteDataManager *manager = webkit_web_view_get_website_data_manager(webView);
		548	#endif
537	webkit_website_data_manager_get_itp_summary(manager, NULL, (GAsyncReadyCallback)gotITPSummaryCallback, itpRequest);	549	webkit_website_data_manager_get_itp_summary(manager, NULL, (GAsyncReadyCallback)gotITPSummaryCallback, itpRequest);
538	}	550	}
539		551
540	static void aboutURISchemeRequestCallback(WebKitURISchemeRequest request, WebKitWebContext webContext)	552	static void aboutURISchemeRequestCallback(WebKitURISchemeRequest *request, gpointer userData)
541	{	553	{
542	GInputStream *stream;	554	GInputStream *stream;
543	gsize streamLength;	555	gsize streamLength;
Lines 557-565 static void aboutURISchemeRequestCallback(WebKitURISchemeRequest *request, WebKi a/Tools/MiniBrowser/gtk/main.c_sec6
557	webkit_uri_scheme_request_finish(request, stream, streamLength, "text/html");	569	webkit_uri_scheme_request_finish(request, stream, streamLength, "text/html");
558	g_object_unref(stream);	570	g_object_unref(stream);
559	} else if (!g_strcmp0(path, "data"))	571	} else if (!g_strcmp0(path, "data"))
560	aboutDataHandleRequest(request, webContext);	572	aboutDataHandleRequest(request);
561	else if (!g_strcmp0(path, "itp"))	573	else if (!g_strcmp0(path, "itp"))
562	aboutITPHandleRequest(request, webContext);	574	aboutITPHandleRequest(request);
563	else {	575	else {
564	error = g_error_new(MINI_BROWSER_ERROR, MINI_BROWSER_ERROR_INVALID_ABOUT_PATH, "Invalid about:%s page.", path);	576	error = g_error_new(MINI_BROWSER_ERROR, MINI_BROWSER_ERROR_INVALID_ABOUT_PATH, "Invalid about:%s page.", path);
565	webkit_uri_scheme_request_finish_error(request, error);	577	webkit_uri_scheme_request_finish_error(request, error);
Lines 660-665 static void startup(GApplication *application) a/Tools/MiniBrowser/gtk/main.c_sec7
660		672
661	static void activate(GApplication application, WebKitSettings webkitSettings)	673	static void activate(GApplication application, WebKitSettings webkitSettings)
662	{	674	{
		675	#if GTK_CHECK_VERSION(3, 98, 0)
		676	WebKitNetworkSession *networkSession = NULL;
		677	if (!automationMode) {
		678	if (privateMode)
		679	networkSession = webkit_network_session_new_ephemeral();
		680	else {
		681	char *dataDirectory = g_build_filename(g_get_user_data_dir(), "webkitgtk-" WEBKITGTK_API_VERSION, "MiniBrowser", NULL);
		682	char *cacheDirectory = g_build_filename(g_get_user_cache_dir(), "webkitgtk-" WEBKITGTK_API_VERSION, "MiniBrowser", NULL);
		683	networkSession = webkit_network_session_new(dataDirectory, cacheDirectory);
		684	g_free(dataDirectory);
		685	g_free(cacheDirectory);
		686	}
		687
		688	webkit_network_session_set_itp_enabled(networkSession, enableITP);
		689
		690	if (proxy) {
		691	WebKitNetworkProxySettings *webkitProxySettings = webkit_network_proxy_settings_new(proxy, ignoreHosts);
		692	webkit_network_session_set_proxy_settings(networkSession, WEBKIT_NETWORK_PROXY_MODE_CUSTOM, webkitProxySettings);
		693	webkit_network_proxy_settings_free(webkitProxySettings);
		694	}
		695
		696	if (ignoreTLSErrors)
		697	webkit_network_session_set_tls_errors_policy(networkSession, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		698
		699	if (cookiesPolicy) {
		700	WebKitCookieManager *cookieManager = webkit_network_session_get_cookie_manager(networkSession);
		701	GEnumClass *enumClass = g_type_class_ref(WEBKIT_TYPE_COOKIE_ACCEPT_POLICY);
		702	GEnumValue *enumValue = g_enum_get_value_by_nick(enumClass, cookiesPolicy);
		703	if (enumValue)
		704	webkit_cookie_manager_set_accept_policy(cookieManager, enumValue->value);
		705	g_type_class_unref(enumClass);
		706	}
		707
		708	if (cookiesFile && !webkit_network_session_is_ephemeral(networkSession)) {
		709	WebKitCookieManager *cookieManager = webkit_network_session_get_cookie_manager(networkSession);
		710	WebKitCookiePersistentStorage storageType = g_str_has_suffix(cookiesFile, ".txt") ? WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT : WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE;
		711	webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesFile, storageType);
		712	}
		713	}
		714	#else
663	WebKitWebsiteDataManager *manager;	715	WebKitWebsiteDataManager *manager;
664	if (privateMode \|\| automationMode)	716	if (privateMode \|\| automationMode)
665	manager = webkit_website_data_manager_new_ephemeral();	717	manager = webkit_website_data_manager_new_ephemeral();
Lines 681-701 static void activate(GApplication application, WebKitSettings webkitSettings) a/Tools/MiniBrowser/gtk/main.c_sec8
681		733
682	if (ignoreTLSErrors)	734	if (ignoreTLSErrors)
683	webkit_website_data_manager_set_tls_errors_policy(manager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	735	webkit_website_data_manager_set_tls_errors_policy(manager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		736	#endif
684		737
685	WebKitWebContext *webContext = g_object_new(WEBKIT_TYPE_WEB_CONTEXT, "website-data-manager", manager,	738	WebKitWebContext *webContext = g_object_new(WEBKIT_TYPE_WEB_CONTEXT,
686	#if !GTK_CHECK_VERSION(3, 98, 0)	739	#if !GTK_CHECK_VERSION(3, 98, 0)
		740	"website-data-manager", manager,
687	"process-swap-on-cross-site-navigation-enabled", TRUE,	741	"process-swap-on-cross-site-navigation-enabled", TRUE,
688	"use-system-appearance-for-scrollbars", FALSE,	742	"use-system-appearance-for-scrollbars", FALSE,
689	#endif	743	#endif
690	"time-zone-override", timeZone,	744	"time-zone-override", timeZone,
691	NULL);	745	NULL);
		746	#if !GTK_CHECK_VERSION(3, 98, 0)
692	g_object_unref(manager);	747	g_object_unref(manager);
		748	#endif
693		749
694	#if !GTK_CHECK_VERSION(3, 98, 0)	750	#if !GTK_CHECK_VERSION(3, 98, 0)
695	if (enableSandbox)	751	if (enableSandbox)
696	webkit_web_context_set_sandbox_enabled(webContext, TRUE);	752	webkit_web_context_set_sandbox_enabled(webContext, TRUE);
697	#endif	753	#endif
698		754
		755	#if !GTK_CHECK_VERSION(3, 98, 0)
699	if (cookiesPolicy) {	756	if (cookiesPolicy) {
700	WebKitCookieManager *cookieManager = webkit_web_context_get_cookie_manager(webContext);	757	WebKitCookieManager *cookieManager = webkit_web_context_get_cookie_manager(webContext);
701	GEnumClass *enumClass = g_type_class_ref(WEBKIT_TYPE_COOKIE_ACCEPT_POLICY);	758	GEnumClass *enumClass = g_type_class_ref(WEBKIT_TYPE_COOKIE_ACCEPT_POLICY);
Lines 710-724 static void activate(GApplication application, WebKitSettings webkitSettings) a/Tools/MiniBrowser/gtk/main.c_sec9
710	WebKitCookiePersistentStorage storageType = g_str_has_suffix(cookiesFile, ".txt") ? WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT : WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE;	767	WebKitCookiePersistentStorage storageType = g_str_has_suffix(cookiesFile, ".txt") ? WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT : WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE;
711	webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesFile, storageType);	768	webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesFile, storageType);
712	}	769	}
		770	#endif
		771
		772	WebKitWebsiteDataManager *dataManager;
		773	#if GTK_CHECK_VERSION(3, 98, 0)
		774	dataManager = networkSession ? webkit_network_session_get_website_data_manager(networkSession) : NULL;
		775	#else
		776	dataManager = webkit_web_context_get_website_data_manager(webContext);
		777	#endif
713		778
714	// Enable the favicon database, by specifying the default directory.	779	// Enable the favicon database.
		780	#if GTK_CHECK_VERSION(3, 98, 0)
		781	webkit_website_data_manager_set_favicons_enabled(dataManager, TRUE);
		782	#else
715	webkit_web_context_set_favicon_database_directory(webContext, NULL);	783	webkit_web_context_set_favicon_database_directory(webContext, NULL);
		784	#endif
716		785
717	webkit_web_context_register_uri_scheme(webContext, BROWSER_ABOUT_SCHEME, (WebKitURISchemeRequestCallback)aboutURISchemeRequestCallback, webContext, NULL);	786	webkit_web_context_register_uri_scheme(webContext, BROWSER_ABOUT_SCHEME, (WebKitURISchemeRequestCallback)aboutURISchemeRequestCallback, NULL, NULL);
718		787
719	WebKitUserContentManager *userContentManager = webkit_user_content_manager_new();	788	WebKitUserContentManager *userContentManager = webkit_user_content_manager_new();
720	webkit_user_content_manager_register_script_message_handler(userContentManager, "aboutData");	789	webkit_user_content_manager_register_script_message_handler(userContentManager, "aboutData");
721	g_signal_connect(userContentManager, "script-message-received::aboutData", G_CALLBACK(aboutDataScriptMessageReceivedCallback), webContext);	790	g_signal_connect(userContentManager, "script-message-received::aboutData", G_CALLBACK(aboutDataScriptMessageReceivedCallback), dataManager);
722		791
723	WebKitWebsitePolicies *defaultWebsitePolicies = webkit_website_policies_new_with_policies(	792	WebKitWebsitePolicies *defaultWebsitePolicies = webkit_website_policies_new_with_policies(
724	"autoplay", autoplayPolicy,	793	"autoplay", autoplayPolicy,
Lines 751-757 static void activate(GApplication application, WebKitSettings webkitSettings) a/Tools/MiniBrowser/gtk/main.c_sec10
751	webkit_web_context_set_automation_allowed(webContext, automationMode);	820	webkit_web_context_set_automation_allowed(webContext, automationMode);
752	g_signal_connect(webContext, "automation-started", G_CALLBACK(automationStartedCallback), application);	821	g_signal_connect(webContext, "automation-started", G_CALLBACK(automationStartedCallback), application);
753		822
		823	#if GTK_CHECK_VERSION(3, 98, 0)
		824	BrowserWindow *mainWindow = BROWSER_WINDOW(browser_window_new(NULL, webContext, networkSession));
		825	#else
754	BrowserWindow *mainWindow = BROWSER_WINDOW(browser_window_new(NULL, webContext));	826	BrowserWindow *mainWindow = BROWSER_WINDOW(browser_window_new(NULL, webContext));
		827	#endif
755	gtk_application_add_window(GTK_APPLICATION(application), GTK_WINDOW(mainWindow));	828	gtk_application_add_window(GTK_APPLICATION(application), GTK_WINDOW(mainWindow));
756	if (darkMode)	829	if (darkMode)
757	g_object_set(gtk_widget_get_settings(GTK_WIDGET(mainWindow)), "gtk-application-prefer-dark-theme", TRUE, NULL);	830	g_object_set(gtk_widget_get_settings(GTK_WIDGET(mainWindow)), "gtk-application-prefer-dark-theme", TRUE, NULL);
Lines 795-800 static void activate(GApplication application, WebKitSettings webkitSettings) a/Tools/MiniBrowser/gtk/main.c_sec11
795	g_object_unref(webContext);	868	g_object_unref(webContext);
796	g_object_unref(userContentManager);	869	g_object_unref(userContentManager);
797	g_object_unref(defaultWebsitePolicies);	870	g_object_unref(defaultWebsitePolicies);
		871	#if GTK_CHECK_VERSION(3, 98, 0)
		872	g_clear_object(&networkSession);
		873	#endif
798		874
799	gtk_widget_grab_focus(firstTab);	875	gtk_widget_grab_focus(firstTab);
800	gtk_widget_show(GTK_WIDGET(mainWindow));	876	gtk_widget_show(GTK_WIDGET(mainWindow));

Lines 254-263 static void testWebViewAuthenticationStorage(AuthenticationTest* test, gconstpoi a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp +15 lines
254	g_assert_false(test->m_authenticationSucceededReceived);	254	g_assert_false(test->m_authenticationSucceededReceived);
255	#endif	255	#endif
256		256
		257	#if ENABLE(2022_GLIB_API)
		258	auto* networkSession = webkit_web_view_get_network_session(test->m_webView);
		259	g_assert_true(webkit_network_session_get_persistent_credential_storage_enabled(networkSession));
		260	webkit_network_session_set_persistent_credential_storage_enabled(networkSession, FALSE);
		261	g_assert_false(webkit_network_session_get_persistent_credential_storage_enabled(networkSession));
		262	#else
257	auto* websiteDataManager = webkit_web_view_get_website_data_manager(test->m_webView);	263	auto* websiteDataManager = webkit_web_view_get_website_data_manager(test->m_webView);
258	g_assert_true(webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager));	264	g_assert_true(webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager));
259	webkit_website_data_manager_set_persistent_credential_storage_enabled(websiteDataManager, FALSE);	265	webkit_website_data_manager_set_persistent_credential_storage_enabled(websiteDataManager, FALSE);
260	g_assert_false(webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager));	266	g_assert_false(webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager));
		267	#endif
261		268
262	test->loadURI(kServer->getURIForPath("/auth-test.html").data());	269	test->loadURI(kServer->getURIForPath("/auth-test.html").data());
263	request = test->waitForAuthenticationRequest();	270	request = test->waitForAuthenticationRequest();
Lines 280-286 static void testWebViewAuthenticationStorage(AuthenticationTest* test, gconstpoi a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp_sec2
280	test->waitUntilLoadFinished();	287	test->waitUntilLoadFinished();
281	g_assert_false(test->m_authenticationCancelledReceived);	288	g_assert_false(test->m_authenticationCancelledReceived);
282	g_assert_true(test->m_authenticationSucceededReceived);	289	g_assert_true(test->m_authenticationSucceededReceived);
		290	#if ENABLE(2022_GLIB_API)
		291	webkit_network_session_set_persistent_credential_storage_enabled(networkSession, TRUE);
		292	#else
283	webkit_website_data_manager_set_persistent_credential_storage_enabled(websiteDataManager, TRUE);	293	webkit_website_data_manager_set_persistent_credential_storage_enabled(websiteDataManager, TRUE);
		294	#endif
284	}	295	}
285		296
286	static void testWebViewAuthenticationSuccess(AuthenticationTest* test, gconstpointer)	297	static void testWebViewAuthenticationSuccess(AuthenticationTest* test, gconstpointer)
Lines 467-474 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp_sec3
467	g_assert_false(m_proxyServer.baseURL().isNull());	478	g_assert_false(m_proxyServer.baseURL().isNull());
468	gProxyServerPort = m_proxyServer.port();	479	gProxyServerPort = m_proxyServer.port();
469	WebKitNetworkProxySettings* settings = webkit_network_proxy_settings_new(m_proxyServer.baseURL().string().utf8().data(), nullptr);	480	WebKitNetworkProxySettings* settings = webkit_network_proxy_settings_new(m_proxyServer.baseURL().string().utf8().data(), nullptr);
		481	#if ENABLE(2022_GLIB_API)
		482	webkit_network_session_set_proxy_settings(m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
		483	#else
470	auto* websiteDataManager = webkit_web_context_get_website_data_manager(m_webContext.get());	484	auto* websiteDataManager = webkit_web_context_get_website_data_manager(m_webContext.get());
471	webkit_website_data_manager_set_network_proxy_settings(websiteDataManager, WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);	485	webkit_website_data_manager_set_network_proxy_settings(websiteDataManager, WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
		486	#endif
472	webkit_network_proxy_settings_free(settings);	487	webkit_network_proxy_settings_free(settings);
473	}	488	}
474		489

Lines 340-345 static void testAutomationSessionRequestSession(AutomationTest* test, gconstpoin a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp +13 lines
340	nullptr));	340	nullptr));
341	g_assert_true(webkit_web_view_is_controlled_by_automation(webView.get()));	341	g_assert_true(webkit_web_view_is_controlled_by_automation(webView.get()));
342	g_assert_cmpuint(webkit_web_view_get_automation_presentation_type(webView.get()), ==, WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_WINDOW);	342	g_assert_cmpuint(webkit_web_view_get_automation_presentation_type(webView.get()), ==, WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_WINDOW);
		343	#if ENABLE(2022_GLIB_API)
		344	// Automation session has its own ephemeral session.
		345	auto* networkSession = webkit_web_view_get_network_session(webView.get());
		346	g_assert_false(networkSession == test->m_networkSession.get());
		347	g_assert_true(webkit_network_session_is_ephemeral(networkSession));
		348	#endif
343	g_assert_true(test->createTopLevelBrowsingContext(webView.get()));	349	g_assert_true(test->createTopLevelBrowsingContext(webView.get()));
344		350
345	auto newWebViewInWindow = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,	351	auto newWebViewInWindow = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
Lines 347-356 static void testAutomationSessionRequestSession(AutomationTest* test, gconstpoin a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp_sec2
347	"backend", Test::createWebViewBackend(),	353	"backend", Test::createWebViewBackend(),
348	#endif	354	#endif
349	"web-context", test->m_webContext.get(),	355	"web-context", test->m_webContext.get(),
		356	#if ENABLE(2022_GLIB_API)
		357	// Check also here that network session property is ignored when is-controlled-by-automation is true.
		358	"network-session", test->m_networkSession.get(),
		359	#endif
350	"is-controlled-by-automation", TRUE,	360	"is-controlled-by-automation", TRUE,
351	nullptr));	361	nullptr));
352	g_assert_true(webkit_web_view_is_controlled_by_automation(newWebViewInWindow.get()));	362	g_assert_true(webkit_web_view_is_controlled_by_automation(newWebViewInWindow.get()));
353	g_assert_cmpuint(webkit_web_view_get_automation_presentation_type(newWebViewInWindow.get()), ==, WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_WINDOW);	363	g_assert_cmpuint(webkit_web_view_get_automation_presentation_type(newWebViewInWindow.get()), ==, WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_WINDOW);
		364	#if ENABLE(2022_GLIB_API)
		365	g_assert_true(webkit_web_view_get_network_session(newWebViewInWindow.get()) == networkSession);
		366	#endif
354	g_assert_true(test->createNewWindow(newWebViewInWindow.get()));	367	g_assert_true(test->createNewWindow(newWebViewInWindow.get()));
355		368
356	auto newWebViewInTab = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,	369	auto newWebViewInTab = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,

Lines 57-65 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp -36 / +88 lines
57		57
58	CookieManagerTest()	58	CookieManagerTest()
59	: WebViewTest()	59	: WebViewTest()
		60	#if ENABLE(2022_GLIB_API)
		61	, m_cookieManager(webkit_network_session_get_cookie_manager(m_networkSession.get()))
		62	, m_websiteDataManager(webkit_network_session_get_website_data_manager(m_networkSession.get()))
		63	#else
60	, m_cookieManager(webkit_web_context_get_cookie_manager(m_webContext.get()))	64	, m_cookieManager(webkit_web_context_get_cookie_manager(m_webContext.get()))
		65	, m_websiteDataManager(webkit_web_context_get_website_data_manager(m_webContext.get()))
		66	#endif
61	{	67	{
62	g_assert_true(webkit_website_data_manager_get_cookie_manager(webkit_web_context_get_website_data_manager(m_webContext.get())) == m_cookieManager);	68	#if !ENABLE(2022_GLIB_API)
		69	g_assert_true(webkit_website_data_manager_get_cookie_manager(m_websiteDataManager) == m_cookieManager);
		70	#endif
63	g_signal_connect(m_cookieManager, "changed", G_CALLBACK(cookiesChangedCallback), this);	71	g_signal_connect(m_cookieManager, "changed", G_CALLBACK(cookiesChangedCallback), this);
64	}	72	}
65		73
Lines 175-202 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp_sec2
175	webkit_cookie_manager_set_accept_policy(m_cookieManager, policy);	183	webkit_cookie_manager_set_accept_policy(m_cookieManager, policy);
176	}	184	}
177		185
178	static void getDomainsReadyCallback(GObject* object, GAsyncResult* result, gpointer userData)	186	GUniquePtr<GList> fetch()
179	{	187	{
180	GUniqueOutPtr<GError> error;	188	struct TestData {
181	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;	189	GUniquePtr<GList> dataList;
182	char** domains = webkit_cookie_manager_get_domains_with_cookies_finish(WEBKIT_COOKIE_MANAGER(object), result, &error.outPtr());	190	GMainLoop* mainLoop;
183	G_GNUC_END_IGNORE_DEPRECATIONS;	191	} data = { nullptr, m_mainLoop };
184	g_assert_no_error(error.get());	192
185		193	webkit_website_data_manager_fetch(m_websiteDataManager, WEBKIT_WEBSITE_DATA_COOKIES, nullptr, [](GObject* object, GAsyncResult* result, gpointer userData) {
186	CookieManagerTest* test = static_cast<CookieManagerTest*>(userData);	194	auto* data = static_cast<TestData*>(userData);
187	test->m_domains = domains;	195	GUniqueOutPtr<GError> error;
188	g_main_loop_quit(test->m_mainLoop);	196	data->dataList.reset(webkit_website_data_manager_fetch_finish(WEBKIT_WEBSITE_DATA_MANAGER(object), result, &error.outPtr()));
		197	g_assert_no_error(error.get());
		198	g_main_loop_quit(data->mainLoop);
		199	}, &data);
		200	g_main_loop_run(m_mainLoop);
		201	return WTFMove(data.dataList);
189	}	202	}
190		203
191	char** getDomains()	204	char** getDomains()
192	{	205	{
193	g_strfreev(m_domains);	206	g_clear_pointer(&m_domains, g_strfreev);
194	m_domains = 0;	207	GUniquePtr<GList> dataList = fetch();
195	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;	208	GPtrArray* domains = g_ptr_array_sized_new(g_list_length(dataList.get()));
196	webkit_cookie_manager_get_domains_with_cookies(m_cookieManager, 0, getDomainsReadyCallback, this);	209	for (GList* item = dataList.get(); item; item = g_list_next(item)) {
197	G_GNUC_END_IGNORE_DEPRECATIONS;	210	auto* data = static_cast<WebKitWebsiteData*>(item->data);
198	g_main_loop_run(m_mainLoop);	211	g_ptr_array_add(domains, g_strdup(webkit_website_data_get_name(data)));
		212	webkit_website_data_unref(data);
		213	}
		214	g_ptr_array_add(domains, nullptr);
199		215
		216	m_domains = reinterpret_cast<char**>(g_ptr_array_free(domains, FALSE));
200	return m_domains;	217	return m_domains;
201	}	218	}
202		219
Lines 214-229 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp_sec3
214		231
215	void deleteCookiesForDomain(const char* domain)	232	void deleteCookiesForDomain(const char* domain)
216	{	233	{
217	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;	234	GUniquePtr<GList> dataList = fetch();
218	webkit_cookie_manager_delete_cookies_for_domain(m_cookieManager, domain);	235	GUniquePtr<GList> cookies;
219	G_GNUC_END_IGNORE_DEPRECATIONS;	236	for (GList* item = dataList.get(); item; item = g_list_next(item)) {
		237	auto* data = static_cast<WebKitWebsiteData*>(item->data);
		238	if (!g_strcmp0(webkit_website_data_get_name(data), domain))
		239	cookies.reset(g_list_prepend(cookies.get(), webkit_website_data_ref(data)));
		240	webkit_website_data_unref(data);
		241	}
		242	webkit_website_data_manager_remove(m_websiteDataManager, WEBKIT_WEBSITE_DATA_COOKIES, cookies.get(), nullptr, nullptr, nullptr);
		243	g_list_foreach(cookies.get(), [](gpointer data, gpointer) {
		244	webkit_website_data_unref(static_cast<WebKitWebsiteData*>(data));
		245	}, nullptr);
220	}	246	}
221		247
222	void deleteAllCookies()	248	void deleteAllCookies()
223	{	249	{
224	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;	250	webkit_website_data_manager_clear(m_websiteDataManager, WEBKIT_WEBSITE_DATA_COOKIES, 0, nullptr, nullptr, nullptr);
225	webkit_cookie_manager_delete_all_cookies(m_cookieManager);
226	G_GNUC_END_IGNORE_DEPRECATIONS;
227	}	251	}
228		252
229	void waitUntilCookiesChanged(int cookiesExpectedToChangeCount = 1)	253	void waitUntilCookiesChanged(int cookiesExpectedToChangeCount = 1)
Lines 235-241 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp_sec4
235	m_finishLoopWhenCookiesChange = false;	259	m_finishLoopWhenCookiesChange = false;
236	}	260	}
237		261
		262	void setITPEnable(bool enable)
		263	{
		264	#if ENABLE(2022_GLIB_API)
		265	webkit_network_session_set_itp_enabled(m_networkSession.get(), enable);
		266	#else
		267	webkit_website_data_manager_set_itp_enabled(m_websiteDataManager, enable);
		268	#endif
		269	}
		270
238	WebKitCookieManager* m_cookieManager { nullptr };	271	WebKitCookieManager* m_cookieManager { nullptr };
		272	WebKitWebsiteDataManager* m_websiteDataManager { nullptr };
239	WebKitCookieAcceptPolicy m_acceptPolicy { WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY };	273	WebKitCookieAcceptPolicy m_acceptPolicy { WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY };
240	char** m_domains { nullptr };	274	char** m_domains { nullptr };
241	GList* m_cookies { nullptr };	275	GList* m_cookies { nullptr };
Lines 278-300 static void testCookieManagerAcceptPolicy(CookieManagerTest* test, gconstpointer a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp_sec5
278	g_assert_cmpint(g_strv_length(domains), ==, 0);	312	g_assert_cmpint(g_strv_length(domains), ==, 0);
279		313
280	// ITP never uses NO_THIRD_PARTY.	314	// ITP never uses NO_THIRD_PARTY.
281	auto* manager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	315	test->setITPEnable(true);
282	webkit_website_data_manager_set_itp_enabled(manager, TRUE);
283	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);	316	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
284	test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);	317	test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
285	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);	318	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
286	webkit_website_data_manager_set_itp_enabled(manager, FALSE);	319	test->setITPEnable(false);
287	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);	320	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
288	webkit_website_data_manager_set_itp_enabled(manager, TRUE);	321	test->setITPEnable(true);
289	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);	322	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
290	webkit_website_data_manager_set_itp_enabled(manager, FALSE);	323	test->setITPEnable(false);
291	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);	324	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
292	test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);	325	test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
293	webkit_website_data_manager_set_itp_enabled(manager, TRUE);	326	test->setITPEnable(true);
294	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);	327	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
295	test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);	328	test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
296	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);	329	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
297	webkit_website_data_manager_set_itp_enabled(manager, FALSE);	330	test->setITPEnable(false);
298	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);	331	g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
299	}	332	}
300		333
Lines 667-681 static void testCookieManagerEphemeral(CookieManagerTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp_sec6
667	g_assert_nonnull(domains);	700	g_assert_nonnull(domains);
668	g_assert_cmpint(g_strv_length(domains), ==, 0);	701	g_assert_cmpint(g_strv_length(domains), ==, 0);
669		702
		703	#if ENABLE(2022_GLIB_API)
		704	GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
		705	#endif
670	auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,	706	auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
671	#if PLATFORM(WPE)	707	#if PLATFORM(WPE)
672	"backend", Test::createWebViewBackend(),	708	"backend", Test::createWebViewBackend(),
673	#endif	709	#endif
674	"web-context", webkit_web_view_get_context(test->m_webView),	710	"web-context", webkit_web_view_get_context(test->m_webView),
		711	#if ENABLE(2022_GLIB_API)
		712	"network-session", ephemeralSession.get(),
		713	#else
675	"is-ephemeral", TRUE,	714	"is-ephemeral", TRUE,
		715	#endif
676	nullptr));	716	nullptr));
		717	#if ENABLE(2022_GLIB_API)
		718	g_assert_true(webkit_web_view_get_network_session(webView.get()) == ephemeralSession.get());
		719	#else
677	g_assert_true(webkit_web_view_is_ephemeral(webView.get()));	720	g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
678	g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(webView.get())));	721	g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(webView.get())));
		722	#endif
679		723
680	g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);	724	g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);
681	webkit_web_view_load_uri(webView.get(), kServer->getURIForPath("/index.html").data());	725	webkit_web_view_load_uri(webView.get(), kServer->getURIForPath("/index.html").data());
Lines 685-708 static void testCookieManagerEphemeral(CookieManagerTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp_sec7
685	g_assert_nonnull(domains);	729	g_assert_nonnull(domains);
686	g_assert_cmpint(g_strv_length(domains), ==, 0);	730	g_assert_cmpint(g_strv_length(domains), ==, 0);
687		731
		732	#if ENABLE(2022_GLIB_API)
		733	auto* viewDataManager = webkit_network_session_get_website_data_manager(ephemeralSession.get());
		734	#else
688	auto* viewDataManager = webkit_web_view_get_website_data_manager(webView.get());	735	auto* viewDataManager = webkit_web_view_get_website_data_manager(webView.get());
		736	#endif
689	g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(viewDataManager));	737	g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(viewDataManager));
690	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(viewDataManager));	738	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(viewDataManager));
		739	#if ENABLE(2022_GLIB_API)
		740	auto* cookieManager = webkit_network_session_get_cookie_manager(ephemeralSession.get());
		741	#else
691	g_assert_true(viewDataManager != webkit_web_context_get_website_data_manager(webkit_web_view_get_context(test->m_webView)));	742	g_assert_true(viewDataManager != webkit_web_context_get_website_data_manager(webkit_web_view_get_context(test->m_webView)));
692	auto* cookieManager = webkit_website_data_manager_get_cookie_manager(viewDataManager);	743	auto* cookieManager = webkit_website_data_manager_get_cookie_manager(viewDataManager);
		744	#endif
693	g_assert_true(WEBKIT_IS_COOKIE_MANAGER(cookieManager));	745	g_assert_true(WEBKIT_IS_COOKIE_MANAGER(cookieManager));
694	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(cookieManager));	746	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(cookieManager));
695	g_assert_true(cookieManager != test->m_cookieManager);	747	g_assert_true(cookieManager != test->m_cookieManager);
696	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;	748	webkit_website_data_manager_fetch(viewDataManager, WEBKIT_WEBSITE_DATA_COOKIES, nullptr, [](GObject* object, GAsyncResult* result, gpointer userData) {
697	webkit_cookie_manager_get_domains_with_cookies(cookieManager, nullptr, [](GObject* object, GAsyncResult* result, gpointer userData) {
698	auto* test = static_cast<CookieManagerTest*>(userData);	749	auto* test = static_cast<CookieManagerTest*>(userData);
699	GUniquePtr<char*> domains(webkit_cookie_manager_get_domains_with_cookies_finish(WEBKIT_COOKIE_MANAGER(object), result, nullptr));	750	GUniquePtr<GList> domains(webkit_website_data_manager_fetch_finish(WEBKIT_WEBSITE_DATA_MANAGER(object), result, nullptr));
700	g_assert_nonnull(domains);	751	g_assert_nonnull(domains);
701	g_assert_cmpint(g_strv_length(domains.get()), ==, 1);	752	g_assert_cmpint(g_list_length(domains.get()), ==, 1);
702	g_assert_cmpstr(domains.get()[0], ==, kFirstPartyDomain);	753	auto* data = static_cast<WebKitWebsiteData*>(domains.get()->data);
		754	g_assert_cmpstr(webkit_website_data_get_name(data), ==, kFirstPartyDomain);
		755	webkit_website_data_unref(data);
703	test->quitMainLoop();	756	test->quitMainLoop();
704	}, test);	757	}, test);
705	G_GNUC_END_IGNORE_DEPRECATIONS;
706	g_main_loop_run(test->m_mainLoop);	758	g_main_loop_run(test->m_mainLoop);
707	}	759	}
708		760

Lines 89-95 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp -12 / +42 lines
89	return TRUE;	89	return TRUE;
90	}	90	}
91		91
92	static void downloadStartedCallback(WebKitWebContext* context, WebKitDownload* download, DownloadTest* test)	92	static void downloadStartedCallback(DownloadTest* test, WebKitDownload* download)
93	{	93	{
94	g_assert_nonnull(webkit_download_get_request(download));	94	g_assert_nonnull(webkit_download_get_request(download));
95	test->started(download);	95	test->started(download);
Lines 106-117 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec2
106	, m_downloadSize(0)	106	, m_downloadSize(0)
107	, m_allowOverwrite(false)	107	, m_allowOverwrite(false)
108	{	108	{
109	g_signal_connect(m_webContext.get(), "download-started", G_CALLBACK(downloadStartedCallback), this);	109	#if ENABLE(2022_GLIB_API)
		110	g_signal_connect_swapped(m_networkSession.get(), "download-started", G_CALLBACK(downloadStartedCallback), this);
		111	#else
		112	g_signal_connect_swapped(m_webContext.get(), "download-started", G_CALLBACK(downloadStartedCallback), this);
		113	#endif
110	}	114	}
111		115
112	~DownloadTest()	116	~DownloadTest()
113	{	117	{
114	g_signal_handlers_disconnect_matched(m_webContext.get(), G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);	118	#if ENABLE(2022_GLIB_API)
		119	g_signal_handlers_disconnect_matched(m_networkSession.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
		120	#else
		121	g_signal_handlers_disconnect_matched(m_webContext.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
		122	#endif
115	g_main_loop_unref(m_mainLoop);	123	g_main_loop_unref(m_mainLoop);
116	}	124	}
117		125
Lines 160-166 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec3
160		168
161	GRefPtr<WebKitDownload> downloadURIAndWaitUntilFinishes(const CString& requestURI)	169	GRefPtr<WebKitDownload> downloadURIAndWaitUntilFinishes(const CString& requestURI)
162	{	170	{
		171	#if ENABLE(2022_GLIB_API)
		172	GRefPtr<WebKitDownload> download = adoptGRef(webkit_network_session_download_uri(m_networkSession.get(), requestURI.data()));
		173	#else
163	GRefPtr<WebKitDownload> download = adoptGRef(webkit_web_context_download_uri(m_webContext.get(), requestURI.data()));	174	GRefPtr<WebKitDownload> download = adoptGRef(webkit_web_context_download_uri(m_webContext.get(), requestURI.data()));
		175	#endif
164	assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download.get()));	176	assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download.get()));
165		177
166	g_assert_false(webkit_download_get_allow_overwrite(download.get()));	178	g_assert_false(webkit_download_get_allow_overwrite(download.get()));
Lines 539-545 class WebViewDownloadTest: public WebViewTest { a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec4
539	public:	551	public:
540	MAKE_GLIB_TEST_FIXTURE(WebViewDownloadTest);	552	MAKE_GLIB_TEST_FIXTURE(WebViewDownloadTest);
541		553
542	static void downloadStartedCallback(WebKitWebContext* context, WebKitDownload* download, WebViewDownloadTest* test)	554	static void downloadStartedCallback(WebViewDownloadTest* test, WebKitDownload* download)
543	{	555	{
544	test->m_download = download;	556	test->m_download = download;
545	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download));	557	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download));
Lines 550-561 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec5
550		562
551	WebViewDownloadTest()	563	WebViewDownloadTest()
552	{	564	{
553	g_signal_connect(webkit_web_view_get_context(m_webView), "download-started", G_CALLBACK(downloadStartedCallback), this);	565	#if ENABLE(2022_GLIB_API)
		566	g_signal_connect_swapped(webkit_web_view_get_network_session(m_webView), "download-started", G_CALLBACK(downloadStartedCallback), this);
		567	#else
		568	g_signal_connect_swapped(webkit_web_view_get_context(m_webView), "download-started", G_CALLBACK(downloadStartedCallback), this);
		569	#endif
554	}	570	}
555		571
556	~WebViewDownloadTest()	572	~WebViewDownloadTest()
557	{	573	{
558	g_signal_handlers_disconnect_matched(webkit_web_view_get_context(m_webView), G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);	574	#if ENABLE(2022_GLIB_API)
		575	g_signal_handlers_disconnect_matched(webkit_web_view_get_network_session(m_webView), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
		576	#else
		577	g_signal_handlers_disconnect_matched(webkit_web_view_get_context(m_webView), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
		578	#endif
559	}	579	}
560		580
561	void waitUntilDownloadStarted()	581	void waitUntilDownloadStarted()
Lines 586-592 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec6
586	}	606	}
587		607
588	#if PLATFORM(GTK)	608	#if PLATFORM(GTK)
		609	#if ENABLE(2022_GLIB_API)
		610	static gboolean contextMenuCallback(WebKitWebView* webView, WebKitContextMenu* contextMenu, WebKitHitTestResult* hitTestResult, WebViewDownloadTest* test)
		611	#else
589	static gboolean contextMenuCallback(WebKitWebView* webView, WebKitContextMenu* contextMenu, GdkEvent, WebKitHitTestResult hitTestResult, WebViewDownloadTest* test)	612	static gboolean contextMenuCallback(WebKitWebView* webView, WebKitContextMenu* contextMenu, GdkEvent, WebKitHitTestResult hitTestResult, WebViewDownloadTest* test)
		613	#endif
590	{	614	{
591	g_assert_true(WEBKIT_IS_HIT_TEST_RESULT(hitTestResult));	615	g_assert_true(WEBKIT_IS_HIT_TEST_RESULT(hitTestResult));
592	GList* items = webkit_context_menu_get_items(contextMenu);	616	GList* items = webkit_context_menu_get_items(contextMenu);
Lines 803-816 static void testDownloadUserAgent(DownloadTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec7
803		827
804	static void testDownloadEphemeralContext(Test* test, gconstpointer)	828	static void testDownloadEphemeralContext(Test* test, gconstpointer)
805	{	829	{
		830	#if ENABLE(2022_GLIB_API)
		831	GRefPtr<WebKitNetworkSession> networkSession = adoptGRef(webkit_network_session_new_ephemeral());
		832	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(networkSession.get()));
		833	#else
806	GRefPtr<WebKitWebsiteDataManager> manager = adoptGRef(webkit_website_data_manager_new_ephemeral());	834	GRefPtr<WebKitWebsiteDataManager> manager = adoptGRef(webkit_website_data_manager_new_ephemeral());
807	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(manager.get()));	835	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(manager.get()));
808	GRefPtr<WebKitWebContext> context = adoptGRef(webkit_web_context_new_with_website_data_manager(manager.get()));	836	GRefPtr<WebKitWebContext> context = adoptGRef(webkit_web_context_new_with_website_data_manager(manager.get()));
809	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context.get()));	837	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context.get()));
810	g_assert_true(webkit_web_context_is_ephemeral(context.get()));	838	g_assert_true(webkit_web_context_is_ephemeral(context.get()));
		839	#endif
811		840
812	GRefPtr<GMainLoop> mainLoop = adoptGRef(g_main_loop_new(nullptr, TRUE));	841	GRefPtr<GMainLoop> mainLoop = adoptGRef(g_main_loop_new(nullptr, TRUE));
		842	#if ENABLE(2022_GLIB_API)
		843	GRefPtr<WebKitDownload> download = adoptGRef(webkit_network_session_download_uri(networkSession.get(), kServer->getURIForPath("/test.pdf").data()));
		844	#else
813	GRefPtr<WebKitDownload> download = adoptGRef(webkit_web_context_download_uri(context.get(), kServer->getURIForPath("/test.pdf").data()));	845	GRefPtr<WebKitDownload> download = adoptGRef(webkit_web_context_download_uri(context.get(), kServer->getURIForPath("/test.pdf").data()));
		846	#endif
814	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download.get()));	847	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download.get()));
815	g_signal_connect(download.get(), "decide-destination", G_CALLBACK(+[](WebKitDownload* download, const gchar* suggestedFilename, gpointer) {	848	g_signal_connect(download.get(), "decide-destination", G_CALLBACK(+[](WebKitDownload* download, const gchar* suggestedFilename, gpointer) {
816	GUniquePtr<char> destination(g_build_filename(Test::dataDirectory(), suggestedFilename, nullptr));	849	GUniquePtr<char> destination(g_build_filename(Test::dataDirectory(), suggestedFilename, nullptr));
Lines 827-833 static void testDownloadEphemeralContext(Test* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec8
827	g_file_delete(destFile.get(), nullptr, nullptr);	860	g_file_delete(destFile.get(), nullptr, nullptr);
828	}	861	}
829		862
830	#if PLATFORM(GTK) && !USE(GTK4)	863	#if PLATFORM(GTK)
831	static void testContextMenuDownloadActions(WebViewDownloadTest* test, gconstpointer)	864	static void testContextMenuDownloadActions(WebViewDownloadTest* test, gconstpointer)
832	{	865	{
833	test->showInWindow();	866	test->showInWindow();
Lines 858-864 static void testContextMenuDownloadActions(WebViewDownloadTest* test, gconstpoin a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec9
858	g_assert_cmpint(g_file_info_get_size(downloadFileInfo.get()), >, 0);	891	g_assert_cmpint(g_file_info_get_size(downloadFileInfo.get()), >, 0);
859	g_file_delete(downloadFile.get(), nullptr, nullptr);	892	g_file_delete(downloadFile.get(), nullptr, nullptr);
860	}	893	}
861	#endif // PLATFORM(GTK) && !USE(GTK4)	894	#endif // PLATFORM(GTK)
862		895
863	#if PLATFORM(GTK)	896	#if PLATFORM(GTK)
864	static void testBlobDownload(WebViewDownloadTest* test, gconstpointer)	897	static void testBlobDownload(WebViewDownloadTest* test, gconstpointer)
Lines 916-927 void beforeAll() a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp_sec10
916	DownloadTest::add("Downloads", "text-plain-mime-type", testDownloadTextPlainMIMEType);	949	DownloadTest::add("Downloads", "text-plain-mime-type", testDownloadTextPlainMIMEType);
917	DownloadTest::add("Downloads", "user-agent", testDownloadUserAgent);	950	DownloadTest::add("Downloads", "user-agent", testDownloadUserAgent);
918	Test::add("Downloads", "ephemeral-context", testDownloadEphemeralContext);	951	Test::add("Downloads", "ephemeral-context", testDownloadEphemeralContext);
919	// FIXME: Implement keyStroke in WPE.
920	#if PLATFORM(GTK)	952	#if PLATFORM(GTK)
921	#if !USE(GTK4)	953	// FIXME: Implement keyStroke in WPE.
922	// FIXME: Rework context menu API in GTK4 to not expose GdkEvent.
923	WebViewDownloadTest::add("Downloads", "contex-menu-download-actions", testContextMenuDownloadActions);	954	WebViewDownloadTest::add("Downloads", "contex-menu-download-actions", testContextMenuDownloadActions);
924	#endif
925	// FIXME: Implement mouse click in WPE.	955	// FIXME: Implement mouse click in WPE.
926	WebViewDownloadTest::add("Downloads", "blob-download", testBlobDownload);	956	WebViewDownloadTest::add("Downloads", "blob-download", testBlobDownload);
927	#endif	957	#endif

Lines 67-75 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp -2 / +127 lines
67		67
68	static void testSSL(SSLTest* test, gconstpointer)	68	static void testSSL(SSLTest* test, gconstpointer)
69	{	69	{
		70	#if ENABLE(2022_GLIB_API)
		71	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		72	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		73	#else
70	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	74	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
71	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	75	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
72	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	76	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		77	#endif
73		78
74	test->loadURI(kHttpsServer->getURIForPath("/").data());	79	test->loadURI(kHttpsServer->getURIForPath("/").data());
75	test->waitUntilLoadFinished();	80	test->waitUntilLoadFinished();
Lines 86-92 static void testSSL(SSLTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec2
86	g_assert_null(test->m_certificate);	91	g_assert_null(test->m_certificate);
87	g_assert_cmpuint(test->m_tlsErrors, ==, 0);	92	g_assert_cmpuint(test->m_tlsErrors, ==, 0);
88		93
		94	#if ENABLE(2022_GLIB_API)
		95	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		96	#else
89	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	97	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		98	#endif
90	}	99	}
91		100
92	class InsecureContentTest: public WebViewTest {	101	class InsecureContentTest: public WebViewTest {
Lines 117-125 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec3
117		126
118	static void testInsecureContent(InsecureContentTest* test, gconstpointer)	127	static void testInsecureContent(InsecureContentTest* test, gconstpointer)
119	{	128	{
		129	#if ENABLE(2022_GLIB_API)
		130	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		131	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		132	#else
120	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	133	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
121	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	134	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
122	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	135	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		136	#endif
123		137
124	test->loadURI(kHttpsServer->getURIForPath("/insecure-content/").data());	138	test->loadURI(kHttpsServer->getURIForPath("/insecure-content/").data());
125	test->waitUntilLoadFinished();	139	test->waitUntilLoadFinished();
Lines 129-144 static void testInsecureContent(InsecureContentTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec4
129	// https://bugs.webkit.org/show_bug.cgi?id=142469	143	// https://bugs.webkit.org/show_bug.cgi?id=142469
130	g_assert_true(test->m_insecureContentDisplayed);	144	g_assert_true(test->m_insecureContentDisplayed);
131		145
		146	#if ENABLE(2022_GLIB_API)
		147	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		148	#else
132	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	149	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		150	#endif
133	}	151	}
134		152
135	static bool assertIfSSLRequestProcessed = false;	153	static bool assertIfSSLRequestProcessed = false;
136		154
137	static void testTLSErrorsPolicy(SSLTest* test, gconstpointer)	155	static void testTLSErrorsPolicy(SSLTest* test, gconstpointer)
138	{	156	{
139	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
140	// TLS errors are treated as transport failures by default.	157	// TLS errors are treated as transport failures by default.
		158	#if ENABLE(2022_GLIB_API)
		159	g_assert_cmpint(webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		160	#else
		161	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
141	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);	162	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		163	#endif
142		164
143	assertIfSSLRequestProcessed = true;	165	assertIfSSLRequestProcessed = true;
144	test->loadURI(kHttpsServer->getURIForPath("/").data());	166	test->loadURI(kHttpsServer->getURIForPath("/").data());
Lines 148-184 static void testTLSErrorsPolicy(SSLTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec5
148	g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));	170	g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));
149	assertIfSSLRequestProcessed = false;	171	assertIfSSLRequestProcessed = false;
150		172
		173	#if ENABLE(2022_GLIB_API)
		174	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		175	g_assert_cmpint(webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()), ==, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		176	#else
151	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	177	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
152	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	178	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		179	#endif
153		180
154	test->m_loadFailed = false;	181	test->m_loadFailed = false;
155	test->loadURI(kHttpsServer->getURIForPath("/").data());	182	test->loadURI(kHttpsServer->getURIForPath("/").data());
156	test->waitUntilLoadFinished();	183	test->waitUntilLoadFinished();
157	g_assert_false(test->m_loadFailed);	184	g_assert_false(test->m_loadFailed);
158		185
159	// An ephemeral web view should keep the same network settings by default.	186	// An ephemeral web view should keep the same network settings.
		187	#if ENABLE(2022_GLIB_API)
		188	GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
		189	webkit_network_session_set_tls_errors_policy(ephemeralSession.get(), webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()));
		190	#endif
160	auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,	191	auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
161	#if PLATFORM(WPE)	192	#if PLATFORM(WPE)
162	"backend", Test::createWebViewBackend(),	193	"backend", Test::createWebViewBackend(),
163	#endif	194	#endif
164	"web-context", test->m_webContext.get(),	195	"web-context", test->m_webContext.get(),
		196	#if ENABLE(2022_GLIB_API)
		197	"network-session", ephemeralSession.get(),
		198	#else
165	"is-ephemeral", TRUE,	199	"is-ephemeral", TRUE,
		200	#endif
166	nullptr));	201	nullptr));
		202	#if ENABLE(2022_GLIB_API)
		203	g_assert_true(webkit_web_view_get_network_session(webView.get()) == ephemeralSession.get());
		204	#else
167	g_assert_true(webkit_web_view_is_ephemeral(webView.get()));	205	g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
168	g_assert_false(webkit_web_context_is_ephemeral(test->m_webContext.get()));	206	g_assert_false(webkit_web_context_is_ephemeral(test->m_webContext.get()));
169	auto* webViewDataManager = webkit_web_view_get_website_data_manager(webView.get());	207	auto* webViewDataManager = webkit_web_view_get_website_data_manager(webView.get());
170	g_assert_false(websiteDataManager == webViewDataManager);	208	g_assert_false(websiteDataManager == webViewDataManager);
171	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, webkit_website_data_manager_get_tls_errors_policy(webViewDataManager));	209	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, webkit_website_data_manager_get_tls_errors_policy(webViewDataManager));
		210	#endif
172		211
		212	#if ENABLE(2022_GLIB_API)
		213	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
		214	g_assert_cmpint(webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		215	#else
173	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);	216	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
174	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);	217	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		218	#endif
175	}	219	}
176		220
177	static void testTLSErrorsRedirect(SSLTest* test, gconstpointer)	221	static void testTLSErrorsRedirect(SSLTest* test, gconstpointer)
178	{	222	{
		223	#if ENABLE(2022_GLIB_API)
		224	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		225	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
		226	#else
179	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	227	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
180	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	228	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
181	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);	229	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		230	#endif
182		231
183	assertIfSSLRequestProcessed = true;	232	assertIfSSLRequestProcessed = true;
184	test->loadURI(kHttpsServer->getURIForPath("/redirect").data());	233	test->loadURI(kHttpsServer->getURIForPath("/redirect").data());
Lines 188-194 static void testTLSErrorsRedirect(SSLTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec6
188	g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));	237	g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));
189	assertIfSSLRequestProcessed = false;	238	assertIfSSLRequestProcessed = false;
190		239
		240	#if ENABLE(2022_GLIB_API)
		241	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		242	#else
191	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	243	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		244	#endif
192	}	245	}
193		246
194	static gboolean webViewAuthenticationCallback(WebKitWebView, WebKitAuthenticationRequest request)	247	static gboolean webViewAuthenticationCallback(WebKitWebView, WebKitAuthenticationRequest request)
Lines 200-208 static gboolean webViewAuthenticationCallback(WebKitWebView*, WebKitAuthenticati a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec7
200		253
201	static void testTLSErrorsHTTPAuth(SSLTest* test, gconstpointer)	254	static void testTLSErrorsHTTPAuth(SSLTest* test, gconstpointer)
202	{	255	{
		256	#if ENABLE(2022_GLIB_API)
		257	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		258	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
		259	#else
203	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	260	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
204	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	261	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
205	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);	262	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		263	#endif
206		264
207	assertIfSSLRequestProcessed = true;	265	assertIfSSLRequestProcessed = true;
208	g_signal_connect(test->m_webView, "authenticate", G_CALLBACK(webViewAuthenticationCallback), NULL);	266	g_signal_connect(test->m_webView, "authenticate", G_CALLBACK(webViewAuthenticationCallback), NULL);
Lines 213-219 static void testTLSErrorsHTTPAuth(SSLTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec8
213	g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));	271	g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));
214	assertIfSSLRequestProcessed = false;	272	assertIfSSLRequestProcessed = false;
215		273
		274	#if ENABLE(2022_GLIB_API)
		275	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		276	#else
216	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	277	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		278	#endif
217	}	279	}
218		280
219	class TLSErrorsTest: public SSLTest {	281	class TLSErrorsTest: public SSLTest {
Lines 248-256 private: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec9
248		310
249	static void testLoadFailedWithTLSErrors(TLSErrorsTest* test, gconstpointer)	311	static void testLoadFailedWithTLSErrors(TLSErrorsTest* test, gconstpointer)
250	{	312	{
		313	#if ENABLE(2022_GLIB_API)
		314	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		315	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
		316	#else
251	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	317	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
252	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	318	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
253	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);	319	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		320	#endif
254		321
255	assertIfSSLRequestProcessed = true;	322	assertIfSSLRequestProcessed = true;
256	// The load-failed-with-tls-errors signal should be emitted when there is a TLS failure.	323	// The load-failed-with-tls-errors signal should be emitted when there is a TLS failure.
Lines 265-271 static void testLoadFailedWithTLSErrors(TLSErrorsTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec10
265	assertIfSSLRequestProcessed = false;	332	assertIfSSLRequestProcessed = false;
266		333
267	// Test allowing an exception for this certificate on this host.	334	// Test allowing an exception for this certificate on this host.
		335	#if ENABLE(2022_GLIB_API)
		336	webkit_network_session_allow_tls_certificate_for_host(test->m_networkSession.get(), test->certificate(), test->host().data());
		337	#else
268	webkit_web_context_allow_tls_certificate_for_host(test->m_webContext.get(), test->certificate(), test->host().data());	338	webkit_web_context_allow_tls_certificate_for_host(test->m_webContext.get(), test->certificate(), test->host().data());
		339	#endif
269	// The page should now load without errors.	340	// The page should now load without errors.
270	test->loadURI(kHttpsServer->getURIForPath("/test-tls/").data());	341	test->loadURI(kHttpsServer->getURIForPath("/test-tls/").data());
271	test->waitUntilTitleChanged();	342	test->waitUntilTitleChanged();
Lines 275-281 static void testLoadFailedWithTLSErrors(TLSErrorsTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec11
275	g_assert_cmpint(test->m_loadEvents[2], ==, LoadTrackingTest::LoadFinished);	346	g_assert_cmpint(test->m_loadEvents[2], ==, LoadTrackingTest::LoadFinished);
276	g_assert_cmpstr(webkit_web_view_get_title(test->m_webView), ==, TLSExpectedSuccessTitle);	347	g_assert_cmpstr(webkit_web_view_get_title(test->m_webView), ==, TLSExpectedSuccessTitle);
277		348
		349	#if ENABLE(2022_GLIB_API)
		350	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		351	#else
278	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	352	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		353	#endif
279	}	354	}
280		355
281	class TLSSubresourceTest : public WebViewTest {	356	class TLSSubresourceTest : public WebViewTest {
Lines 334-341 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec12
334		409
335	static void testSubresourceLoadFailedWithTLSErrors(TLSSubresourceTest* test, gconstpointer)	410	static void testSubresourceLoadFailedWithTLSErrors(TLSSubresourceTest* test, gconstpointer)
336	{	411	{
		412	#if ENABLE(2022_GLIB_API)
		413	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		414	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
		415	#else
337	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	416	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
		417	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
338	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);	418	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		419	#endif
339		420
340	assertIfSSLRequestProcessed = true;	421	assertIfSSLRequestProcessed = true;
341	test->loadURI(kHttpServer->getURIForPath("/").data());	422	test->loadURI(kHttpServer->getURIForPath("/").data());
Lines 343-348 static void testSubresourceLoadFailedWithTLSErrors(TLSSubresourceTest* test, gco a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec13
343	g_assert_true(G_IS_TLS_CERTIFICATE(test->m_certificate.get()));	424	g_assert_true(G_IS_TLS_CERTIFICATE(test->m_certificate.get()));
344	g_assert_cmpuint(test->m_tlsErrors, ==, G_TLS_CERTIFICATE_UNKNOWN_CA);	425	g_assert_cmpuint(test->m_tlsErrors, ==, G_TLS_CERTIFICATE_UNKNOWN_CA);
345	assertIfSSLRequestProcessed = false;	426	assertIfSSLRequestProcessed = false;
		427
		428	#if ENABLE(2022_GLIB_API)
		429	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		430	#else
		431	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		432	#endif
		433
346	}	434	}
347		435
348	class WebSocketTest : public WebViewTest {	436	class WebSocketTest : public WebViewTest {
Lines 420-428 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec14
420		508
421	static void testWebSocketTLSErrors(WebSocketTest* test, gconstpointer)	509	static void testWebSocketTLSErrors(WebSocketTest* test, gconstpointer)
422	{	510	{
		511	#if ENABLE(2022_GLIB_API)
		512	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		513	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
		514	#else
423	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	515	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
424	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	516	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
425	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);	517	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		518	#endif
426		519
427	// First, check that insecure ws:// web sockets work fine.	520	// First, check that insecure ws:// web sockets work fine.
428	unsigned events = test->connectToServerAndWaitForEvents(kHttpServer);	521	unsigned events = test->connectToServerAndWaitForEvents(kHttpServer);
Lines 440-452 static void testWebSocketTLSErrors(WebSocketTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec15
440	g_assert_true(events & WebSocketTest::EventFlags::DidClose);	533	g_assert_true(events & WebSocketTest::EventFlags::DidClose);
441		534
442	// Now try wss:// again, this time ignoring TLS errors.	535	// Now try wss:// again, this time ignoring TLS errors.
		536	#if ENABLE(2022_GLIB_API)
		537	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		538	#else
443	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	539	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		540	#endif
444	events = test->connectToServerAndWaitForEvents(kHttpsServer);	541	events = test->connectToServerAndWaitForEvents(kHttpsServer);
445	g_assert_true(events & WebSocketTest::EventFlags::DidServerCompleteHandshake);	542	g_assert_true(events & WebSocketTest::EventFlags::DidServerCompleteHandshake);
446	g_assert_true(events & WebSocketTest::EventFlags::DidOpen);	543	g_assert_true(events & WebSocketTest::EventFlags::DidOpen);
447	g_assert_false(events & WebSocketTest::EventFlags::DidClose);	544	g_assert_false(events & WebSocketTest::EventFlags::DidClose);
448		545
		546	#if ENABLE(2022_GLIB_API)
		547	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		548	#else
449	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	549	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		550	#endif
450	}	551	}
451		552
452	class EphemeralSSLTest : public SSLTest {	553	class EphemeralSSLTest : public SSLTest {
Lines 466-474 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec16
466		567
467	static void testTLSErrorsEphemeral(EphemeralSSLTest* test, gconstpointer)	568	static void testTLSErrorsEphemeral(EphemeralSSLTest* test, gconstpointer)
468	{	569	{
		570	#if ENABLE(2022_GLIB_API)
		571	auto* networkSession = webkit_web_view_get_network_session(test->m_webView);
		572	g_assert_true(webkit_network_session_is_ephemeral(networkSession));
		573	g_assert_cmpint(webkit_network_session_get_tls_errors_policy(networkSession), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		574	#else
469	auto* websiteDataManager = webkit_web_view_get_website_data_manager(test->m_webView);	575	auto* websiteDataManager = webkit_web_view_get_website_data_manager(test->m_webView);
470	g_assert_true(webkit_website_data_manager_is_ephemeral(websiteDataManager));	576	g_assert_true(webkit_website_data_manager_is_ephemeral(websiteDataManager));
471	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);	577	g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
		578	#endif
472		579
473	test->loadURI(kHttpsServer->getURIForPath("/").data());	580	test->loadURI(kHttpsServer->getURIForPath("/").data());
474	test->waitUntilLoadFinished();	581	test->waitUntilLoadFinished();
Lines 564-572 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec17
564	static void testClientSideCertificate(ClientSideCertificateTest* test, gconstpointer)	671	static void testClientSideCertificate(ClientSideCertificateTest* test, gconstpointer)
565	{	672	{
566	// Ignore server certificate errors.	673	// Ignore server certificate errors.
		674	#if ENABLE(2022_GLIB_API)
		675	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		676	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		677	#else
567	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	678	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
568	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	679	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
569	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	680	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		681	#endif
570		682
571	// Cancel the authentiation request.	683	// Cancel the authentiation request.
572	test->loadURI(kHttpsServer->getURIForPath("/").data());	684	test->loadURI(kHttpsServer->getURIForPath("/").data());
Lines 650-656 static void testClientSideCertificate(ClientSideCertificateTest* test, gconstpoi a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec18
650	g_assert_cmpint(test->m_loadEvents[2], ==, LoadTrackingTest::LoadFinished);	762	g_assert_cmpint(test->m_loadEvents[2], ==, LoadTrackingTest::LoadFinished);
651	test->m_loadEvents.clear();	763	test->m_loadEvents.clear();
652		764
		765	#if ENABLE(2022_GLIB_API)
		766	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		767	#else
653	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	768	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		769	#endif
654	}	770	}
655		771
656	class WebSocketClientSideCertificateTest final : public WebSocketTest, public ClientSideCertificateTestBase {	772	class WebSocketClientSideCertificateTest final : public WebSocketTest, public ClientSideCertificateTestBase {
Lines 676-684 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec19
676	static void testWebSocketClientSideCertificate(WebSocketClientSideCertificateTest* test, gconstpointer)	792	static void testWebSocketClientSideCertificate(WebSocketClientSideCertificateTest* test, gconstpointer)
677	{	793	{
678	// Ignore server certificate errors.	794	// Ignore server certificate errors.
		795	#if ENABLE(2022_GLIB_API)
		796	WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
		797	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		798	#else
679	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	799	auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
680	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);	800	WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
681	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);	801	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
		802	#endif
682		803
683	// Try first without having the certificate in credential storage.	804	// Try first without having the certificate in credential storage.
684	auto events = test->connectToServerAndWaitForEvents(kHttpsServer);	805	auto events = test->connectToServerAndWaitForEvents(kHttpsServer);
Lines 698-704 static void testWebSocketClientSideCertificate(WebSocketClientSideCertificateTes a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp_sec20
698	g_assert_true(events & WebSocketTest::EventFlags::DidOpen);	819	g_assert_true(events & WebSocketTest::EventFlags::DidOpen);
699	g_assert_false(events & WebSocketTest::EventFlags::DidClose);	820	g_assert_false(events & WebSocketTest::EventFlags::DidClose);
700		821
		822	#if ENABLE(2022_GLIB_API)
		823	webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
		824	#else
701	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);	825	webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
		826	#endif
702	}	827	}
703	#endif	828	#endif
704		829




static void testFaviconDatabaseEphemeral(FaviconDatabaseTest* test, gconstpointer)
{
#if !ENABLE(2022_GLIB_API)
    // If the context is ephemeral, the database is not created if it doesn't exist.
    GRefPtr<WebKitWebContext> ephemeralContext = adoptGRef(webkit_web_context_new_ephemeral());
    GUniquePtr<char> databaseDirectory(g_build_filename(Test::dataDirectory(), "testFaviconDatabaseEphemeral", nullptr));

    // 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)



    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.

    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>";

#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)

    kServer->removeWebSocketHandler();
#endif
}
#endif

class MemoryPressureTest : public WebViewTest {
public:

    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)

    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);

Lines 219-229 static void ephemeralViewloadChanged(WebKitWebView* webView, WebKitLoadEvent loa a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebView.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebView.cpp +17 lines
219		219
220	static void testWebViewEphemeral(WebViewTest* test, gconstpointer)	220	static void testWebViewEphemeral(WebViewTest* test, gconstpointer)
221	{	221	{
		222	#if ENABLE(2022_GLIB_API)
		223	auto* networkSession = webkit_web_view_get_network_session(test->m_webView);
		224	g_assert_false(webkit_network_session_is_ephemeral(networkSession));
		225	auto* manager = webkit_network_session_get_website_data_manager(networkSession);
		226	g_assert_false(webkit_website_data_manager_is_ephemeral(manager));
		227	GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
		228	#else
222	g_assert_false(webkit_web_view_is_ephemeral(test->m_webView));	229	g_assert_false(webkit_web_view_is_ephemeral(test->m_webView));
223	g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(test->m_webView)));	230	g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(test->m_webView)));
224	auto* manager = webkit_web_context_get_website_data_manager(test->m_webContext.get());	231	auto* manager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
225	g_assert_false(webkit_website_data_manager_is_ephemeral(manager));	232	g_assert_false(webkit_website_data_manager_is_ephemeral(manager));
226	g_assert_true(webkit_web_view_get_website_data_manager(test->m_webView) == manager);	233	g_assert_true(webkit_web_view_get_website_data_manager(test->m_webView) == manager);
		234	#endif
227	webkit_website_data_manager_clear(manager, WEBKIT_WEBSITE_DATA_DISK_CACHE, 0, nullptr, [](GObject* manager, GAsyncResult* result, gpointer userData) {	235	webkit_website_data_manager_clear(manager, WEBKIT_WEBSITE_DATA_DISK_CACHE, 0, nullptr, [](GObject* manager, GAsyncResult* result, gpointer userData) {
228	webkit_website_data_manager_clear_finish(WEBKIT_WEBSITE_DATA_MANAGER(manager), result, nullptr);	236	webkit_website_data_manager_clear_finish(WEBKIT_WEBSITE_DATA_MANAGER(manager), result, nullptr);
229	static_cast<WebViewTest*>(userData)->quitMainLoop();	237	static_cast<WebViewTest*>(userData)->quitMainLoop();
Lines 236-246 static void testWebViewEphemeral(WebViewTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebView.cpp_sec2
236	"backend", Test::createWebViewBackend(),	244	"backend", Test::createWebViewBackend(),
237	#endif	245	#endif
238	"web-context", webkit_web_view_get_context(test->m_webView),	246	"web-context", webkit_web_view_get_context(test->m_webView),
		247	#if ENABLE(2022_GLIB_API)
		248	"network-session", ephemeralSession.get(),
		249	#else
239	"is-ephemeral", TRUE,	250	"is-ephemeral", TRUE,
		251	#endif
240	nullptr));	252	nullptr));
		253	#if ENABLE(2022_GLIB_API)
		254	g_assert_true(webkit_network_session_is_ephemeral(webkit_web_view_get_network_session(webView.get())));
		255	g_assert_true(webkit_web_view_get_network_session(webView.get()) != networkSession);
		256	#else
241	g_assert_true(webkit_web_view_is_ephemeral(webView.get()));	257	g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
242	g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(webView.get())));	258	g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(webView.get())));
243	g_assert_true(webkit_web_view_get_website_data_manager(webView.get()) != manager);	259	g_assert_true(webkit_web_view_get_website_data_manager(webView.get()) != manager);
		260	#endif
244		261
245	g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);	262	g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);
246	webkit_web_view_load_uri(webView.get(), gServer->getURIForPath("/").data());	263	webkit_web_view_load_uri(webView.get(), gServer->getURIForPath("/").data());



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));

    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());

    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);

    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));


    test->clear(persistentCaches, 0);
    g_assert_null(test->fetch(persistentCaches));

    // 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));

    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));

    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)
{


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()));


    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_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());

    }, 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)

    webkit_settings_set_enable_mock_capture_devices(settings, enabled);
}

#if !ENABLE(2022_GLIB_API)
static void testWebsiteDataITP(WebsiteDataTest* test, gconstpointer)
{
    GUniquePtr<char> itpDirectory(g_build_filename(Test::dataDirectory(), "itp", nullptr));
    GUniquePtr<char> itpDatabaseFile(g_build_filename(itpDirectory.get(), "observations.db", nullptr));
    ALLOW_DEPRECATED_DECLARATIONS_END
    GUniquePtr<char> itpDatabaseFile(g_build_filename(itpDirectory, "observations.db", nullptr));

    // Delete any previous data.
    g_unlink(itpDatabaseFile.get());
    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));
#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.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.

    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.get());
}
#endif

static void testWebsiteDataServiceWorkerRegistrations(WebsiteDataTest* test, gconstpointer)
{

        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)

    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);

    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);

Lines 36-44 static void testUIProcessAutocleanups(WebViewTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGtk/TestAutocleanups.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGtk/TestAutocleanups.cpp -1 / +7 lines
36	g_assert_true(WEBKIT_IS_WEB_CONTEXT(context));	36	g_assert_true(WEBKIT_IS_WEB_CONTEXT(context));
37	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context));	37	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context));
38		38
		39	#if ENABLE(2022_GLIB_API)
		40	g_autoptr(WebKitNetworkSession) session = webkit_network_session_new(nullptr, nullptr);
		41	g_assert_true(WEBKIT_IS_NETWORK_SESSION(session));
		42	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(session));
		43	#else
39	g_autoptr(WebKitWebsiteDataManager) manager = webkit_website_data_manager_new(nullptr);	44	g_autoptr(WebKitWebsiteDataManager) manager = webkit_website_data_manager_new(nullptr);
40	g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));	45	g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
41	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context));	46	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(manager));
		47	#endif
42		48
43	g_autoptr(WebKitUserScript) userScript = webkit_user_script_new("",	49	g_autoptr(WebKitUserScript) userScript = webkit_user_script_new("",
44	WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES, WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,	50	WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES, WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,



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)

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)
endif ()

macro(ADD_WPE_QT_TEST test_name)
    add_executable(${test_name} ${ARGN} ${TOOLS_DIR}/TestWebKitAPI/Tests/WPEQt/WPEQtTest.cpp)
    set_target_properties(${test_name} PROPERTIES

Lines 127-132 int main(int argc, char** argv) a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp_sec1
- a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp +2 lines
127	g_set_prgname(FileSystem::currentExecutableName().data());	127	g_set_prgname(FileSystem::currentExecutableName().data());
128	g_setenv("WEBKIT_EXEC_PATH", WEBKIT_EXEC_PATH, FALSE);	128	g_setenv("WEBKIT_EXEC_PATH", WEBKIT_EXEC_PATH, FALSE);
129	g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE);	129	g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE);
		130	// Sandbox requires using GApplication.
		131	g_setenv("WEBKIT_DISABLE_SANDBOX_THIS_IS_DANGEROUS", "1", TRUE);
130	g_setenv("LC_ALL", "C", TRUE);	132	g_setenv("LC_ALL", "C", TRUE);
131	g_setenv("GIO_USE_VFS", "local", TRUE);	133	g_setenv("GIO_USE_VFS", "local", TRUE);
132	g_setenv("GSETTINGS_BACKEND", "memory", TRUE);	134	g_setenv("GSETTINGS_BACKEND", "memory", TRUE);

Lines 120-125 public: a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h_sec1
- a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h -1 / +14 lines
120		120
121	Test()	121	Test()
122	{	122	{
		123	#if ENABLE(2022_GLIB_API)
		124	m_networkSession = adoptGRef(webkit_network_session_new(dataDirectory(), dataDirectory()));
		125	assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_networkSession.get()));
		126
		127	m_webContext = adoptGRef(WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT, "memory-pressure-settings", s_memoryPressureSettings, nullptr)));
		128	#else
123	GRefPtr<WebKitWebsiteDataManager> websiteDataManager = adoptGRef(webkit_website_data_manager_new(	129	GRefPtr<WebKitWebsiteDataManager> websiteDataManager = adoptGRef(webkit_website_data_manager_new(
124	"base-data-directory", dataDirectory(),	130	"base-data-directory", dataDirectory(),
125	"base-cache-directory", dataDirectory(),	131	"base-cache-directory", dataDirectory(),
Lines 127-138 public: a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h_sec2
127		133
128	m_webContext = adoptGRef(WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT,	134	m_webContext = adoptGRef(WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT,
129	"website-data-manager", websiteDataManager.get(),	135	"website-data-manager", websiteDataManager.get(),
130	#if PLATFORM(GTK) && !USE(GTK4)	136	#if PLATFORM(GTK)
131	"process-swap-on-cross-site-navigation-enabled", TRUE,	137	"process-swap-on-cross-site-navigation-enabled", TRUE,
132	"use-system-appearance-for-scrollbars", FALSE,	138	"use-system-appearance-for-scrollbars", FALSE,
133	#endif	139	#endif
134	"memory-pressure-settings", s_memoryPressureSettings,	140	"memory-pressure-settings", s_memoryPressureSettings,
135	nullptr)));	141	nullptr)));
		142	#endif
136	assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_webContext.get()));	143	assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_webContext.get()));
137	g_signal_connect(m_webContext.get(), "initialize-web-extensions", G_CALLBACK(initializeWebExtensionsCallback), this);	144	g_signal_connect(m_webContext.get(), "initialize-web-extensions", G_CALLBACK(initializeWebExtensionsCallback), this);
138	}	145	}
Lines 141-146 public: a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h_sec3
141	{	148	{
142	g_signal_handlers_disconnect_matched(m_webContext.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);	149	g_signal_handlers_disconnect_matched(m_webContext.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
143	m_webContext = nullptr;	150	m_webContext = nullptr;
		151	#if ENABLE(2022_GLIB_API)
		152	m_networkSession = nullptr;
		153	#endif
144	if (m_watchedObjects.isEmpty())	154	if (m_watchedObjects.isEmpty())
145	return;	155	return;
146		156
Lines 279-284 public: a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h_sec4
279		289
280	HashSet<GObject*> m_watchedObjects;	290	HashSet<GObject*> m_watchedObjects;
281	GRefPtr<WebKitWebContext> m_webContext;	291	GRefPtr<WebKitWebContext> m_webContext;
		292	#if ENABLE(2022_GLIB_API)
		293	GRefPtr<WebKitNetworkSession> m_networkSession;
		294	#endif
282	static GRefPtr<GDBusServer> s_dbusServer;	295	static GRefPtr<GDBusServer> s_dbusServer;
283	static Vector<GRefPtr<GDBusConnection>> s_dbusConnections;	296	static Vector<GRefPtr<GDBusConnection>> s_dbusConnections;
284	static HashMap<uint64_t, GDBusConnection*> s_dbusConnectionPageMap;	297	static HashMap<uint64_t, GDBusConnection*> s_dbusConnectionPageMap;

Lines 52-64 void WebViewTest::initializeWebView() a/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp_sec1
- a/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp +8 lines
52	{	52	{
53	g_assert_null(m_webView);	53	g_assert_null(m_webView);
54		54
		55	#if ENABLE(2022_GLIB_API)
		56	GRefPtr<WebKitNetworkSession> networkSession = shouldCreateEphemeralWebView ? adoptGRef(webkit_network_session_new_ephemeral()) : m_networkSession;
		57	#endif
		58
55	m_webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,	59	m_webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
56	#if PLATFORM(WPE)	60	#if PLATFORM(WPE)
57	"backend", Test::createWebViewBackend(),	61	"backend", Test::createWebViewBackend(),
58	#endif	62	#endif
59	"web-context", m_webContext.get(),	63	"web-context", m_webContext.get(),
60	"user-content-manager", m_userContentManager.get(),	64	"user-content-manager", m_userContentManager.get(),
		65	#if ENABLE(2022_GLIB_API)
		66	"network-session", networkSession.get(),
		67	#else
61	"is-ephemeral", shouldCreateEphemeralWebView,	68	"is-ephemeral", shouldCreateEphemeralWebView,
		69	#endif
62	nullptr));	70	nullptr));
63		71
64	platformInitializeWebView();	72	platformInitializeWebView();

Return to Bug 222366

Line 0 a/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.h.in_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.h.in +133 lines
		1	/*
		2	* Copyright (C) 2023 Igalia S.L.
		3	*
		4	* This library is free software; you can redistribute it and/or
		5	* modify it under the terms of the GNU Lesser General Public
		6	* License as published by the Free Software Foundation; either
		7	* version 2,1 of the License, or (at your option) any later version.
		8	*
		9	* This library is distributed in the hope that it will be useful,
		10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		12	* Library General Public License for more details.
		13	*
		14	* You should have received a copy of the GNU Library General Public License
		15	* along with this library; see the file COPYING.LIB. If not, write to
		16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
		17	* Boston, MA 02110-1301, USA.
		18	*/
		19
		20	@API_SINGLE_HEADER_CHECK@
		21
		22	#ifndef WebKitNetworkSession_h
		23	#define WebKitNetworkSession_h
		24
		25	#include <gio/gio.h>
		26	#include <@API_INCLUDE_PREFIX@/WebKitCookieManager.h>
		27	#include <@API_INCLUDE_PREFIX@/WebKitDefines.h>
		28	#include <@API_INCLUDE_PREFIX@/WebKitDownload.h>
		29	#include <@API_INCLUDE_PREFIX@/WebKitMemoryPressureSettings.h>
		30	#include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>
		31	#include <@API_INCLUDE_PREFIX@/WebKitWebsiteDataManager.h>
		32
		33	G_BEGIN_DECLS
		34
		35	#define WEBKIT_TYPE_NETWORK_SESSION (webkit_network_session_get_type())
		36	#define WEBKIT_NETWORK_SESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_NETWORK_SESSION, WebKitNetworkSession))
		37	#define WEBKIT_IS_NETWORK_SESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_NETWORK_SESSION))
		38	#define WEBKIT_NETWORK_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), WEBKIT_TYPE_NETWORK_SESSION, WebKitNetworkSessionClass))
		39	#define WEBKIT_IS_NETWORK_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), WEBKIT_TYPE_NETWORK_SESSION))
		40	#define WEBKIT_NETWORK_SESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), WEBKIT_TYPE_NETWORK_SESSION, WebKitNetworkSessionClass))
		41
		42	typedef struct _WebKitNetworkSession WebKitNetworkSession;
		43	typedef struct _WebKitNetworkSessionClass WebKitNetworkSessionClass;
		44	typedef struct _WebKitNetworkSessionPrivate WebKitNetworkSessionPrivate;
		45
		46	struct _WebKitNetworkSession {
		47	GObject parent;
		48
		49	/< private >/
		50	WebKitNetworkSessionPrivate *priv;
		51	};
		52
		53	struct _WebKitNetworkSessionClass {
		54	GObjectClass parent_class;
		55
		56	/< private >/
		57	void (*_webkit_reserved0) (void);
		58	void (*_webkit_reserved1) (void);
		59	void (*_webkit_reserved2) (void);
		60	void (*_webkit_reserved3) (void);
		61	};
		62
		63	WEBKIT_API GType
		64	webkit_network_session_get_type (void);
65
66	WEBKIT_API WebKitNetworkSession *
67	webkit_network_session_get_default (void);
68
69	WEBKIT_API WebKitNetworkSession *
70	webkit_network_session_new (const char *data_directory,
71	const char *cache_directrory);
72	WEBKIT_API WebKitNetworkSession *
73	webkit_network_session_new_ephemeral (void);
74
75	WEBKIT_API gboolean
76	webkit_network_session_is_ephemeral (WebKitNetworkSession *session);
77
78	WEBKIT_API WebKitWebsiteDataManager *
79	webkit_network_session_get_website_data_manager (WebKitNetworkSession *session);
80
81	WEBKIT_API WebKitCookieManager *
82	webkit_network_session_get_cookie_manager (WebKitNetworkSession *session);
83
84	WEBKIT_API void
85	webkit_network_session_set_itp_enabled (WebKitNetworkSession *session,
86	gboolean enabled);
87
88	WEBKIT_API gboolean
89	webkit_network_session_get_itp_enabled (WebKitNetworkSession *session);
90
91	WEBKIT_API void
92	webkit_network_session_set_persistent_credential_storage_enabled (WebKitNetworkSession *session,
93	gboolean enabled);
94
95	WEBKIT_API gboolean
96	webkit_network_session_get_persistent_credential_storage_enabled (WebKitNetworkSession *session);
97
98	WEBKIT_API void
99	webkit_network_session_set_tls_errors_policy (WebKitNetworkSession *session,
100	WebKitTLSErrorsPolicy policy);
101
102	WEBKIT_API WebKitTLSErrorsPolicy
103	webkit_network_session_get_tls_errors_policy (WebKitNetworkSession *session);
104
105	WEBKIT_API void
106	webkit_network_session_allow_tls_certificate_for_host (WebKitNetworkSession *session,
107	GTlsCertificate *certificate,
108	const char *host);
109
110	WEBKIT_API void
111	webkit_network_session_set_proxy_settings (WebKitNetworkSession *session,
112	WebKitNetworkProxyMode proxy_mode,
113	WebKitNetworkProxySettings *proxy_settings);
114
115	WEBKIT_API void
116	webkit_network_session_set_memory_pressure_settings (WebKitMemoryPressureSettings *settings);
117
118	WEBKIT_API void
119	webkit_network_session_get_itp_summary (WebKitNetworkSession *session,
120	GCancellable *cancellable,
121	GAsyncReadyCallback callback,
122	gpointer user_data);
123	WEBKIT_API GList *
124	webkit_network_session_get_itp_summary_finish (WebKitNetworkSession *session,
125	GAsyncResult *result,
126	GError **error);
127	WEBKIT_API WebKitDownload *
128	webkit_network_session_download_uri (WebKitNetworkSession *session,
129	const char *uri);
130
131	G_END_DECLS
132
133	#endif

Line 0 a/Source/WebKit/UIProcess/API/glib/WebKitNetworkSessionPrivate.h_sec1
- a/Source/WebKit/UIProcess/API/glib/WebKitNetworkSessionPrivate.h +25 lines
	1	/*
	2	* Copyright (C) 2015 Igalia S.L.
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Library General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Library General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public License
	15	* along with this library; see the file COPYING.LIB. If not, write to
	16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	17	* Boston, MA 02110-1301, USA.
	18	*/
	19
	20	#pragma once
	21
	22	#include "WebKitDownload.h"
	23	#include "WebKitNetworkSession.h"
	24
	25	void webkitNetworkSessionDownloadStarted(WebKitNetworkSession, WebKitDownload);

Lines 351-357 GtkWidget* webkit_web_view_new_with_context(WebKitWebContext* context) a/Source/WebKit/UIProcess/API/gtk/WebKitWebViewGtk.cpp_sec1
- a/Source/WebKit/UIProcess/API/gtk/WebKitWebViewGtk.cpp +2 lines
351	g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);	351	g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);
352		352
353	return GTK_WIDGET(g_object_new(WEBKIT_TYPE_WEB_VIEW,	353	return GTK_WIDGET(g_object_new(WEBKIT_TYPE_WEB_VIEW,
		354	#if !ENABLE(2022_GLIB_API)
354	"is-ephemeral", webkit_web_context_is_ephemeral(context),	355	"is-ephemeral", webkit_web_context_is_ephemeral(context),
		356	#endif
355	"web-context", context,	357	"web-context", context,
356	nullptr));	358	nullptr));
357	}	359	}

Lines 109-115 WebKitWebView* webkit_web_view_new_with_context(WebKitWebViewBackend* backend, W a/Source/WebKit/UIProcess/API/wpe/WebKitWebViewWPE.cpp_sec1
- a/Source/WebKit/UIProcess/API/wpe/WebKitWebViewWPE.cpp +2 lines
109		109
110	return WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,	110	return WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
111	"backend", backend,	111	"backend", backend,
		112	#if !ENABLE(2022_GLIB_API)
112	"is-ephemeral", webkit_web_context_is_ephemeral(context),	113	"is-ephemeral", webkit_web_context_is_ephemeral(context),
		114	#endif
113	"web-context", context,	115	"web-context", context,
114	nullptr));	116	nullptr));
115	}	117	}

Lines 249-254 static void ephemeralViewFaviconChanged(WebKitWebView* webView, GParamSpec*, Web a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFaviconDatabase.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFaviconDatabase.cpp +2 lines
249		249
250	static void testFaviconDatabaseEphemeral(FaviconDatabaseTest* test, gconstpointer)	250	static void testFaviconDatabaseEphemeral(FaviconDatabaseTest* test, gconstpointer)
251	{	251	{
		252	#if !ENABLE(2022_GLIB_API)
252	// If the context is ephemeral, the database is not created if it doesn't exist.	253	// If the context is ephemeral, the database is not created if it doesn't exist.
253	GRefPtr<WebKitWebContext> ephemeralContext = adoptGRef(webkit_web_context_new_ephemeral());	254	GRefPtr<WebKitWebContext> ephemeralContext = adoptGRef(webkit_web_context_new_ephemeral());
254	GUniquePtr<char> databaseDirectory(g_build_filename(Test::dataDirectory(), "testFaviconDatabaseEphemeral", nullptr));	255	GUniquePtr<char> databaseDirectory(g_build_filename(Test::dataDirectory(), "testFaviconDatabaseEphemeral", nullptr));
Lines 283-288 static void testFaviconDatabaseEphemeral(FaviconDatabaseTest* test, gconstpointe a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFaviconDatabase.cpp_sec2
283	// Page URL loaded in ephemeral web view is not in the database.	284	// Page URL loaded in ephemeral web view is not in the database.
284	g_assert_null(webkit_favicon_database_get_favicon_uri(ephemeralDatabase, kServer->getURIForPath("/bar").data()));	285	g_assert_null(webkit_favicon_database_get_favicon_uri(ephemeralDatabase, kServer->getURIForPath("/bar").data()));
285	ephemeralContext = nullptr;	286	ephemeralContext = nullptr;
		287	#endif
286	}	288	}
287		289
288	void testFaviconDatabaseClear(FaviconDatabaseTest* test, gconstpointer)	290	void testFaviconDatabaseClear(FaviconDatabaseTest* test, gconstpointer)

Lines 41-46 static void testWebContextDefault(Test* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp +8 lines
41	g_assert_true(webkit_web_context_get_default() != test->m_webContext.get());	41	g_assert_true(webkit_web_context_get_default() != test->m_webContext.get());
42	}	42	}
43		43
		44	#if !ENABLE(2022_GLIB_API)
44	static void testWebContextEphemeral(Test* test, gconstpointer)	45	static void testWebContextEphemeral(Test* test, gconstpointer)
45	{	46	{
46	// By default web contexts are not ephemeral.	47	// By default web contexts are not ephemeral.
Lines 78-83 static void testWebContextEphemeral(Test* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp_sec2
78	context = adoptGRef(webkit_web_context_new_with_website_data_manager(ephemeralManager.get()));	79	context = adoptGRef(webkit_web_context_new_with_website_data_manager(ephemeralManager.get()));
79	g_assert_true(webkit_web_context_is_ephemeral(context.get()));	80	g_assert_true(webkit_web_context_is_ephemeral(context.get()));
80	}	81	}
		82	#endif
81		83
82	static const char* kBarHTML = "<html><body>Bar</body></html>";	84	static const char* kBarHTML = "<html><body>Bar</body></html>";
83	static const char* kEchoHTMLFormat = "<html><body>%s</body></html>";	85	static const char* kEchoHTMLFormat = "<html><body>%s</body></html>";
Lines 768-773 public: a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp_sec3
768	#endif	770	#endif
769	};	771	};
770		772
		773	#if !ENABLE(2022_GLIB_API)
771	#if SOUP_CHECK_VERSION(2, 61, 90)	774	#if SOUP_CHECK_VERSION(2, 61, 90)
772	#if USE(SOUP2)	775	#if USE(SOUP2)
773	static void webSocketServerCallback(SoupServer, SoupWebsocketConnection, const char, SoupClientContext, gpointer userData)	776	static void webSocketServerCallback(SoupServer, SoupWebsocketConnection, const char, SoupClientContext, gpointer userData)
Lines 881-886 static void testWebContextProxySettings(ProxyTest* test, gconstpointer) a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp_sec4
881	kServer->removeWebSocketHandler();	884	kServer->removeWebSocketHandler();
882	#endif	885	#endif
883	}	886	}
		887	#endif
884		888
885	class MemoryPressureTest : public WebViewTest {	889	class MemoryPressureTest : public WebViewTest {
886	public:	890	public:
Lines 1066-1072 void beforeAll() a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp_sec5
1066	kServer->run(serverCallback);	1070	kServer->run(serverCallback);
1067		1071
1068	Test::add("WebKitWebContext", "default-context", testWebContextDefault);	1072	Test::add("WebKitWebContext", "default-context", testWebContextDefault);
		1073	#if !ENABLE(2022_GLIB_API)
1069	Test::add("WebKitWebContext", "ephemeral", testWebContextEphemeral);	1074	Test::add("WebKitWebContext", "ephemeral", testWebContextEphemeral);
		1075	#endif
1070	URISchemeTest::add("WebKitWebContext", "uri-scheme", testWebContextURIScheme);	1076	URISchemeTest::add("WebKitWebContext", "uri-scheme", testWebContextURIScheme);
1071	// FIXME: implement spellchecker in WPE.	1077	// FIXME: implement spellchecker in WPE.
1072	#if PLATFORM(GTK)	1078	#if PLATFORM(GTK)
Lines 1075-1081 void beforeAll() a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp_sec6
1075	WebViewTest::add("WebKitWebContext", "languages", testWebContextLanguages);	1081	WebViewTest::add("WebKitWebContext", "languages", testWebContextLanguages);
1076	SecurityPolicyTest::add("WebKitSecurityManager", "security-policy", testWebContextSecurityPolicy);	1082	SecurityPolicyTest::add("WebKitSecurityManager", "security-policy", testWebContextSecurityPolicy);
1077	WebViewTest::add("WebKitSecurityManager", "file-xhr", testWebContextSecurityFileXHR);	1083	WebViewTest::add("WebKitSecurityManager", "file-xhr", testWebContextSecurityFileXHR);
		1084	#if !ENABLE(2022_GLIB_API)
1078	ProxyTest::add("WebKitWebContext", "proxy", testWebContextProxySettings);	1085	ProxyTest::add("WebKitWebContext", "proxy", testWebContextProxySettings);
		1086	#endif
1079	MemoryPressureTest::add("WebKitWebContext", "memory-pressure", testMemoryPressureSettings);	1087	MemoryPressureTest::add("WebKitWebContext", "memory-pressure", testMemoryPressureSettings);
1080	WebViewTest::add("WebKitWebContext", "timezone", testWebContextTimeZoneOverride);	1088	WebViewTest::add("WebKitWebContext", "timezone", testWebContextTimeZoneOverride);
1081	WebViewTest::add("WebKitWebContext", "timezone-worker", testWebContextTimeZoneOverrideInWorker);	1089	WebViewTest::add("WebKitWebContext", "timezone-worker", testWebContextTimeZoneOverrideInWorker);

Lines 144-149 ADD_WK2_TEST_WEB_EXTENSION(WebProcessTest ${WebKitGLibAPIWebProcessTests}) a/Tools/TestWebKitAPI/glib/CMakeLists.txt_sec1
- a/Tools/TestWebKitAPI/glib/CMakeLists.txt -5 / +1 lines
144	ADD_WK2_TEST(TestAuthentication ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp)	144	ADD_WK2_TEST(TestAuthentication ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp)
145	ADD_WK2_TEST(TestAutomationSession ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp)	145	ADD_WK2_TEST(TestAutomationSession ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp)
146	ADD_WK2_TEST(TestBackForwardList ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestBackForwardList.cpp)	146	ADD_WK2_TEST(TestBackForwardList ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestBackForwardList.cpp)
		147	ADD_WK2_TEST(TestCookieManager ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp)
147	ADD_WK2_TEST(TestDownloads ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp)	148	ADD_WK2_TEST(TestDownloads ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp)
148	ADD_WK2_TEST(TestWebKitFindController ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFindController.cpp)	149	ADD_WK2_TEST(TestWebKitFindController ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFindController.cpp)
149	ADD_WK2_TEST(TestEditor ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestEditor.cpp)	150	ADD_WK2_TEST(TestEditor ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestEditor.cpp)
Lines 168-178 ADD_WK2_TEST(TestDOMElement ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestDOME a/Tools/TestWebKitAPI/glib/CMakeLists.txt_sec2
168	ADD_WK2_TEST(TestGeolocationManager ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestGeolocationManager.cpp)	169	ADD_WK2_TEST(TestGeolocationManager ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestGeolocationManager.cpp)
169	ADD_WK2_TEST(TestInputMethodContext ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestInputMethodContext.cpp)	170	ADD_WK2_TEST(TestInputMethodContext ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestInputMethodContext.cpp)
170		171
171	# FIXME: Enable for WPE and GTK4
172	if (PORT STREQUAL "GTK" AND NOT USE_GTK4)
173	ADD_WK2_TEST(TestCookieManager ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp)
174	endif ()
175
176	macro(ADD_WPE_QT_TEST test_name)	172	macro(ADD_WPE_QT_TEST test_name)
177	add_executable(${test_name} ${ARGN} ${TOOLS_DIR}/TestWebKitAPI/Tests/WPEQt/WPEQtTest.cpp)	173	add_executable(${test_name} ${ARGN} ${TOOLS_DIR}/TestWebKitAPI/Tests/WPEQt/WPEQtTest.cpp)
178	set_target_properties(${test_name} PROPERTIES	174	set_target_properties(${test_name} PROPERTIES