/*

* Copyright (C) 2009-2022 Apple Inc. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

* THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "WebProcess.h"

#include "APIFrameHandle.h"

#include "APIPageHandle.h"

#include "AudioMediaStreamTrackRendererInternalUnitManager.h"

#include "AuthenticationManager.h"

#include "AuxiliaryProcessMessages.h"

#include "DrawingArea.h"

#include "EventDispatcher.h"

#include "GPUProcessConnectionParameters.h"

#include "InjectedBundle.h"

#include "LibWebRTCNetwork.h"

#include "Logging.h"

#include "NetworkConnectionToWebProcessMessages.h"

#include "NetworkProcessConnection.h"

#include "NetworkProcessConnectionInfo.h"

#include "NetworkSession.h"

#include "NetworkSessionCreationParameters.h"

#include "ProcessAssertion.h"

#include "RemoteAudioHardwareListener.h"

#include "RemoteAudioSession.h"

#include "RemoteLegacyCDMFactory.h"

#include "RemoteMediaEngineConfigurationFactory.h"

#include "RemoteRemoteCommandListener.h"

#include "RemoteWebLockRegistry.h"

#include "SpeechRecognitionRealtimeMediaSourceManager.h"

#include "StorageAreaMap.h"

#include "UserData.h"

#include "WebAutomationSessionProxy.h"

#include "WebBroadcastChannelRegistry.h"

#include "WebCacheStorageProvider.h"

#include "WebConnectionToUIProcess.h"

#include "WebCookieJar.h"

#include "WebCoreArgumentCoders.h"

#include "WebFileSystemStorageConnection.h"

#include "WebFrame.h"

#include "WebFrameNetworkingContext.h"

#include "WebGamepadProvider.h"

#include "WebGeolocationManager.h"

#include "WebIDBConnectionToServer.h"

#include "WebLoaderStrategy.h"

#include "WebMediaKeyStorageManager.h"

#include "WebMemorySampler.h"

#include "WebMessagePortChannelProvider.h"

#include "WebPage.h"

#include "WebPageCreationParameters.h"

#include "WebPageGroupProxy.h"

#include "WebPaymentCoordinator.h"

#include "WebPlatformStrategies.h"

#include "WebPluginInfoProvider.h"

#include "WebProcessCreationParameters.h"

#include "WebProcessDataStoreParameters.h"

#include "WebProcessMessages.h"

#include "WebProcessPoolMessages.h"

#include "WebProcessProxyMessages.h"

#include "WebResourceLoadObserver.h"

#include "WebSWClientConnection.h"

#include "WebSWContextManagerConnection.h"

#include "WebSWContextManagerConnectionMessages.h"

#include "WebServiceWorkerProvider.h"

#include "WebSocketStream.h"

#include "WebsiteData.h"

#include "WebsiteDataStoreParameters.h"

#include "WebsiteDataType.h"

#include <JavaScriptCore/JSLock.h>

#include <JavaScriptCore/MemoryStatistics.h>

#include <JavaScriptCore/WasmFaultSignalHandler.h>

#include <WebCore/AXObjectCache.h>

#include <WebCore/ApplicationCacheStorage.h>

#include <WebCore/AuthenticationChallenge.h>

#include <WebCore/BackForwardCache.h>

#include <WebCore/CPUMonitor.h>

#include <WebCore/CommonVM.h>

#include <WebCore/CrossOriginPreflightResultCache.h>

#include <WebCore/DNS.h>

#include <WebCore/DOMWindow.h>

#include <WebCore/DatabaseTracker.h>

#include <WebCore/DeprecatedGlobalSettings.h>

#include <WebCore/DiagnosticLoggingClient.h>

#include <WebCore/DiagnosticLoggingKeys.h>

#include <WebCore/FontCache.h>

#include <WebCore/FontCascade.h>

#include <WebCore/Frame.h>

#include <WebCore/FrameLoader.h>

#include <WebCore/GCController.h>

#include <WebCore/GlyphPage.h>

#include <WebCore/HTMLMediaElement.h>

#include <WebCore/JSDOMWindow.h>

#include <WebCore/LegacySchemeRegistry.h>

#include <WebCore/MediaEngineConfigurationFactory.h>

#include <WebCore/MemoryCache.h>

#include <WebCore/MemoryRelease.h>

#include <WebCore/MessagePort.h>

#include <WebCore/MockRealtimeMediaSourceCenter.h>

#include <WebCore/NetworkStorageSession.h>

#include <WebCore/Page.h>

#include <WebCore/PageGroup.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/PlatformMediaSessionManager.h>

#include <WebCore/ProcessWarming.h>

#include <WebCore/RegistrableDomain.h>

#include <WebCore/RemoteCommandListener.h>

#include <WebCore/ResourceLoadStatistics.h>

#include <WebCore/RuntimeApplicationChecks.h>

#include <WebCore/RuntimeEnabledFeatures.h>

#include <WebCore/ScriptExecutionContext.h>

#include <WebCore/SecurityOrigin.h>

#include <WebCore/ServiceWorkerContextData.h>

#include <WebCore/Settings.h>

#include <WebCore/UserGestureIndicator.h>

#include <pal/Logging.h>

#include <wtf/Algorithms.h>

#include <wtf/CallbackAggregator.h>

#include <wtf/Language.h>

#include <wtf/ProcessPrivilege.h>

#include <wtf/RunLoop.h>

#include <wtf/SystemTracing.h>

#include <wtf/URLParser.h>

#include <wtf/text/StringHash.h>

#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)

#include "ARKitInlinePreviewModelPlayerMac.h"

#endif

#if !OS(WINDOWS)

#include <unistd.h>

#endif

#if PLATFORM(WAYLAND)

#include "WaylandCompositorDisplay.h"

#endif

#if PLATFORM(COCOA)

#include "ObjCObjectGraph.h"

#include "UserMediaCaptureManager.h"

#endif

#if PLATFORM(MAC)

#include <WebCore/DisplayRefreshMonitorManager.h>

#endif

#if PLATFORM(IOS_FAMILY)

#include "WebSQLiteDatabaseTracker.h"

#endif

#if ENABLE(SEC_ITEM_SHIM)

#include "SecItemShim.h"

#endif

#if ENABLE(NOTIFICATIONS)

#include "WebNotificationManager.h"

#endif

#if ENABLE(GPU_PROCESS)

#include "GPUConnectionToWebProcessMessages.h"

#include "GPUProcessConnection.h"

#include "GPUProcessConnectionInfo.h"

#endif

#if ENABLE(WEB_AUTHN)

#include "WebAuthnConnectionToWebProcessMessages.h"

#include "WebAuthnProcessConnection.h"

#include "WebAuthnProcessConnectionInfo.h"

#endif

#if ENABLE(REMOTE_INSPECTOR)

#include <JavaScriptCore/RemoteInspector.h>

#endif

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaPlayerManager.h"

#endif

#if USE(LIBWEBRTC) && PLATFORM(COCOA) && ENABLE(GPU_PROCESS)

#include "LibWebRTCCodecs.h"

#endif

#if ENABLE(ENCRYPTED_MEDIA)

#include "RemoteCDMFactory.h"

#endif

#if PLATFORM(IOS_FAMILY)

#include "RemoteMediaSessionHelper.h"

#endif

#if ENABLE(ROUTING_ARBITRATION)

#include "AudioSessionRoutingArbitrator.h"

#endif

#if ENABLE(GPU_PROCESS) && HAVE(AVASSETREADER)

#include "RemoteImageDecoderAVF.h"

#include <WebCore/ImageDecoder.h>

#endif

#if PLATFORM(COCOA)

#include <WebCore/SystemBattery.h>

#include <WebCore/VP9UtilitiesCocoa.h>

#endif

#if OS(LINUX)

#include <wtf/linux/RealTimeThreads.h>

#endif

#undef WEBPROCESS_RELEASE_LOG

#define RELEASE_LOG_SESSION_ID (m_sessionID ? m_sessionID->toUInt64() : 0)

#if RELEASE_LOG_DISABLED

#define WEBPROCESS_RELEASE_LOG(channel, fmt, ...) UNUSED_VARIABLE(this)

#define WEBPROCESS_RELEASE_LOG_ERROR(channel, fmt, ...) UNUSED_VARIABLE(this)

#else

#define WEBPROCESS_RELEASE_LOG(channel, fmt, ...) RELEASE_LOG(channel, "%p - [sessionID=%" PRIu64 "] WebProcess::" fmt, this, RELEASE_LOG_SESSION_ID, ##__VA_ARGS__)

#define WEBPROCESS_RELEASE_LOG_ERROR(channel, fmt, ...) RELEASE_LOG_ERROR(channel, "%p - [sessionID=%" PRIu64 "] WebProcess::" fmt, this, RELEASE_LOG_SESSION_ID, ##__VA_ARGS__)

#endif

// This should be less than plugInAutoStartExpirationTimeThreshold in PlugInAutoStartProvider.

static const Seconds plugInAutoStartExpirationTimeUpdateThreshold { 29 * 24 * 60 * 60 };

// This should be greater than tileRevalidationTimeout in TileController.

static const Seconds nonVisibleProcessGraphicsCleanupDelay { 10_s };

#if ENABLE(NON_VISIBLE_WEBPROCESS_MEMORY_CLEANUP_TIMER)

// This should be long enough to support a workload where a user is actively switching between multiple tabs,

// since our memory cleanup routine could potentially delete a good amount of JIT code.

static const Seconds nonVisibleProcessMemoryCleanupDelay { 120_s };

#endif

namespace WebKit {

using namespace JSC;

using namespace WebCore;

NO_RETURN static void callExit(IPC::Connection*)

{

#if OS(WINDOWS)

// Calling _exit in non-main threads may cause a deadlock in WTF::Thread::ThreadHolder::~ThreadHolder.

TerminateProcess(GetCurrentProcess(), EXIT_SUCCESS);

#else

_exit(EXIT_SUCCESS);

#endif

}

WebProcess& WebProcess::singleton()

{

static WebProcess& process = *new WebProcess;

return process;

}

WebProcess::WebProcess()

: m_eventDispatcher(EventDispatcher::create())

#if PLATFORM(IOS_FAMILY)

, m_viewUpdateDispatcher(ViewUpdateDispatcher::create())

#endif

, m_webInspectorInterruptDispatcher(WebInspectorInterruptDispatcher::create())

, m_webLoaderStrategy(*new WebLoaderStrategy)

, m_cacheStorageProvider(WebCacheStorageProvider::create())

, m_broadcastChannelRegistry(WebBroadcastChannelRegistry::create())

, m_webLockRegistry(RemoteWebLockRegistry::create(*this))

, m_cookieJar(WebCookieJar::create())

, m_dnsPrefetchHystereris([this](PAL::HysteresisState state) { if (state == PAL::HysteresisState::Stopped) m_dnsPrefetchedHosts.clear(); })

, m_nonVisibleProcessGraphicsCleanupTimer(*this, &WebProcess::nonVisibleProcessGraphicsCleanupTimerFired)

#if ENABLE(NON_VISIBLE_WEBPROCESS_MEMORY_CLEANUP_TIMER)

, m_nonVisibleProcessMemoryCleanupTimer(*this, &WebProcess::nonVisibleProcessMemoryCleanupTimerFired)

#endif

#if PLATFORM(IOS_FAMILY)

, m_webSQLiteDatabaseTracker([this](bool isHoldingLockedFiles) { parentProcessConnection()->send(Messages::WebProcessProxy::SetIsHoldingLockedFiles(isHoldingLockedFiles), 0); })

#endif

{

// Initialize our platform strategies.

WebPlatformStrategies::initialize();

// FIXME: This should moved to where WebProcess::initialize is called,

// so that ports have a chance to customize, and ifdefs in this file are

// limited.

addSupplement<WebGeolocationManager>();

#if ENABLE(NOTIFICATIONS)

addSupplement<WebNotificationManager>();

#endif

#if ENABLE(LEGACY_ENCRYPTED_MEDIA)

addSupplement<WebMediaKeyStorageManager>();

#endif

#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)

addSupplement<UserMediaCaptureManager>();

#endif

#if ENABLE(GPU_PROCESS)

addSupplement<RemoteMediaPlayerManager>();

#endif

#if ENABLE(GPU_PROCESS) && HAVE(AVASSETREADER)

addSupplement<RemoteImageDecoderAVFManager>();

#endif

#if ENABLE(GPU_PROCESS) && ENABLE(ENCRYPTED_MEDIA)

addSupplement<RemoteCDMFactory>();

#endif

#if ENABLE(GPU_PROCESS) && ENABLE(LEGACY_ENCRYPTED_MEDIA)

addSupplement<RemoteLegacyCDMFactory>();

#endif

#if ENABLE(ROUTING_ARBITRATION)

addSupplement<AudioSessionRoutingArbitrator>();

#endif

#if ENABLE(GPU_PROCESS)

addSupplement<RemoteMediaEngineConfigurationFactory>();

#endif

Gigacage::forbidDisablingPrimitiveGigacage();

}

WebProcess::~WebProcess()

{

ASSERT_NOT_REACHED();

}

void WebProcess::initializeProcess(const AuxiliaryProcessInitializationParameters& parameters)

{

WTF::setProcessPrivileges({ });

MessagePortChannelProvider::setSharedProvider(WebMessagePortChannelProvider::singleton());

platformInitializeProcess(parameters);

updateCPULimit();

}

void WebProcess::initializeConnection(IPC::Connection* connection)

{

AuxiliaryProcess::initializeConnection(connection);

// We call _exit() directly from the background queue in case the main thread is unresponsive

// and AuxiliaryProcess::didClose() does not get called.

connection->setDidCloseOnConnectionWorkQueueCallback(callExit);

#if !PLATFORM(GTK) && !PLATFORM(WPE) && !ENABLE(IPC_TESTING_API)

connection->setShouldExitOnSyncMessageSendFailure(true);

#endif

m_eventDispatcher->initializeConnection(connection);

#if PLATFORM(IOS_FAMILY)

m_viewUpdateDispatcher->initializeConnection(connection);

#endif // PLATFORM(IOS_FAMILY)

m_webInspectorInterruptDispatcher->initializeConnection(connection);

for (auto& supplement : m_supplements.values())

supplement->initializeConnection(connection);

m_webConnection = WebConnectionToUIProcess::create(this);

}

static void scheduleLogMemoryStatistics(LogMemoryStatisticsReason reason)

{

// Log stats in the next turn of the run loop so that it runs after the low memory handler.

RunLoop::main().dispatch([reason] {

WebCore::logMemoryStatistics(reason);

});

}

void WebProcess::initializeWebProcess(WebProcessCreationParameters&& parameters)

{

TraceScope traceScope(InitializeWebProcessStart, InitializeWebProcessEnd);

ASSERT(m_pageMap.isEmpty());

if (parameters.websiteDataStoreParameters)

setWebsiteDataStoreParameters(WTFMove(*parameters.websiteDataStoreParameters));

WebCore::setPresentingApplicationPID(parameters.presentingApplicationPID);

#if OS(LINUX)

MemoryPressureHandler::ReliefLogger::setLoggingEnabled(parameters.shouldEnableMemoryPressureReliefLogging);

#endif

platformInitializeWebProcess(parameters);

// Match the QoS of the UIProcess and the scrolling thread but use a slightly lower priority.

WTF::Thread::setCurrentThreadIsUserInteractive(-1);

m_suppressMemoryPressureHandler = parameters.shouldSuppressMemoryPressureHandler;

if (!m_suppressMemoryPressureHandler) {

auto& memoryPressureHandler = MemoryPressureHandler::singleton();

memoryPressureHandler.setLowMemoryHandler([this] (Critical critical, Synchronous synchronous) {

// If this process contains only non-visible content (e.g. only contains background

// tabs), then treat the memory warning as if it was a critical warning to maximize the

// amount of memory released for foreground apps to use.

if (m_pagesInWindows.isEmpty() && critical == Critical::No)

critical = Critical::Yes;

#if PLATFORM(MAC)

// If this is a process we keep around for performance, kill it on memory pressure instead of trying to free up its memory.

if (m_processType == ProcessType::CachedWebContent || m_processType == ProcessType::PrewarmedWebContent || areAllPagesSuspended()) {

if (m_processType == ProcessType::CachedWebContent)

WEBPROCESS_RELEASE_LOG(Process, "initializeWebProcess: Cached WebProcess is exiting due to memory pressure");

else if (m_processType == ProcessType::PrewarmedWebContent)

WEBPROCESS_RELEASE_LOG(Process, "initializeWebProcess: Prewarmed WebProcess is exiting due to memory pressure");

else

WEBPROCESS_RELEASE_LOG(Process, "initializeWebProcess: Suspended WebProcess is exiting due to memory pressure");

stopRunLoop();

return;

}

#endif

auto maintainBackForwardCache = m_isSuspending ? WebCore::MaintainBackForwardCache::Yes : WebCore::MaintainBackForwardCache::No;

auto maintainMemoryCache = m_isSuspending && m_hasSuspendedPageProxy ? WebCore::MaintainMemoryCache::Yes : WebCore::MaintainMemoryCache::No;

WebCore::releaseMemory(critical, synchronous, maintainBackForwardCache, maintainMemoryCache);

for (auto& page : m_pageMap.values())

page->releaseMemory(critical);

});

#if ENABLE(PERIODIC_MEMORY_MONITOR)

memoryPressureHandler.setShouldUsePeriodicMemoryMonitor(true);

memoryPressureHandler.setMemoryKillCallback([this] () {

WebCore::logMemoryStatistics(LogMemoryStatisticsReason::OutOfMemoryDeath);

if (MemoryPressureHandler::singleton().processState() == WebsamProcessState::Active)

parentProcessConnection()->send(Messages::WebProcessProxy::DidExceedActiveMemoryLimit(), 0);

else

parentProcessConnection()->send(Messages::WebProcessProxy::DidExceedInactiveMemoryLimit(), 0);

});

memoryPressureHandler.setDidExceedInactiveLimitWhileActiveCallback([this] () {

parentProcessConnection()->send(Messages::WebProcessProxy::DidExceedInactiveMemoryLimitWhileActive(), 0);

if (!m_loggedProcessLimitCriticalMemoryStatistics) {

m_loggedProcessLimitCriticalMemoryStatistics = true;

scheduleLogMemoryStatistics(LogMemoryStatisticsReason::CriticalMemoryPressureNotification);

}

});

#endif

memoryPressureHandler.setMemoryPressureStatusChangedCallback([this](WTF::MemoryPressureStatus memoryPressureStatus) {

if (parentProcessConnection())

parentProcessConnection()->send(Messages::WebProcessProxy::MemoryPressureStatusChanged(MemoryPressureHandler::singleton().isUnderMemoryPressure()), 0);

if (memoryPressureStatus == WTF::MemoryPressureStatus::ProcessLimitWarning && !m_loggedProcessLimitWarningMemoryStatistics) {

m_loggedProcessLimitWarningMemoryStatistics = true;

scheduleLogMemoryStatistics(LogMemoryStatisticsReason::WarningMemoryPressureNotification);

} else if (memoryPressureStatus == WTF::MemoryPressureStatus::ProcessLimitCritical && !m_loggedProcessLimitCriticalMemoryStatistics) {

m_loggedProcessLimitCriticalMemoryStatistics = true;

scheduleLogMemoryStatistics(LogMemoryStatisticsReason::CriticalMemoryPressureNotification);

}

});

memoryPressureHandler.install();

PAL::registerNotifyCallback("com.apple.WebKit.logMemStats", [] {

WebCore::logMemoryStatistics(LogMemoryStatisticsReason::DebugNotification);

});

}

SandboxExtension::consumePermanently(parameters.additionalSandboxExtensionHandles);

if (!parameters.injectedBundlePath.isEmpty())

m_injectedBundle = InjectedBundle::create(parameters, transformHandlesToObjects(parameters.initializationUserData.object()).get());

for (auto& supplement : m_supplements.values())

supplement->initialize(parameters);

setCacheModel(parameters.cacheModel);

if (!parameters.overrideLanguages.isEmpty()) {

LOG_WITH_STREAM(Language, stream << "Web Process initialization is setting overrideLanguages: " << parameters.overrideLanguages);

overrideUserPreferredLanguages(parameters.overrideLanguages);

} else

LOG(Language, "Web process initialization is not setting overrideLanguages");

m_textCheckerState = parameters.textCheckerState;

m_fullKeyboardAccessEnabled = parameters.fullKeyboardAccessEnabled;

#if HAVE(MOUSE_DEVICE_OBSERVATION)

m_hasMouseDevice = parameters.hasMouseDevice;

#endif

#if HAVE(STYLUS_DEVICE_OBSERVATION)

m_hasStylusDevice = parameters.hasStylusDevice;

#endif

for (auto& scheme : parameters.urlSchemesRegisteredAsEmptyDocument)

registerURLSchemeAsEmptyDocument(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsSecure)

registerURLSchemeAsSecure(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsBypassingContentSecurityPolicy)

registerURLSchemeAsBypassingContentSecurityPolicy(scheme);

for (auto& scheme : parameters.urlSchemesForWhichDomainRelaxationIsForbidden)

setDomainRelaxationForbiddenForURLScheme(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsLocal)

registerURLSchemeAsLocal(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsNoAccess)

registerURLSchemeAsNoAccess(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsDisplayIsolated)

registerURLSchemeAsDisplayIsolated(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsCORSEnabled)

LegacySchemeRegistry::registerURLSchemeAsCORSEnabled(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsAlwaysRevalidated)

registerURLSchemeAsAlwaysRevalidated(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsCachePartitioned)

registerURLSchemeAsCachePartitioned(scheme);

for (auto& scheme : parameters.urlSchemesRegisteredAsCanDisplayOnlyIfCanRequest)

registerURLSchemeAsCanDisplayOnlyIfCanRequest(scheme);

setDefaultRequestTimeoutInterval(parameters.defaultRequestTimeoutInterval);

setBackForwardCacheCapacity(parameters.backForwardCacheCapacity);

setAlwaysUsesComplexTextCodePath(parameters.shouldAlwaysUseComplexTextCodePath);

setShouldUseFontSmoothing(parameters.shouldUseFontSmoothing);

setTerminationTimeout(parameters.terminationTimeout);

setMemoryCacheDisabled(parameters.memoryCacheDisabled);

WebCore::RuntimeEnabledFeatures::sharedFeatures().setAttrStyleEnabled(parameters.attrStyleEnabled);

commonVM().setGlobalConstRedeclarationShouldThrow(parameters.shouldThrowExceptionForGlobalConstantRedeclaration);

ScriptExecutionContext::setCrossOriginMode(parameters.crossOriginMode);

m_isCaptivePortalModeEnabled = parameters.isCaptivePortalModeEnabled;

#if ENABLE(SERVICE_CONTROLS)

setEnabledServices(parameters.hasImageServices, parameters.hasSelectionServices, parameters.hasRichContentServices);

#endif

#if ENABLE(REMOTE_INSPECTOR) && PLATFORM(COCOA)

if (std::optional<audit_token_t> auditToken = parentProcessConnection()->getAuditToken()) {

RetainPtr<CFDataRef> auditData = adoptCF(CFDataCreate(nullptr, (const UInt8*)&*auditToken, sizeof(*auditToken)));

Inspector::RemoteInspector::singleton().setParentProcessInformation(WebCore::presentingApplicationPID(), auditData);

}

#endif

#if ENABLE(GAMEPAD)

GamepadProvider::singleton().setSharedProvider(WebGamepadProvider::singleton());

#endif

#if ENABLE(SERVICE_WORKER)

ServiceWorkerProvider::setSharedProvider(WebServiceWorkerProvider::singleton());

#endif

#if ENABLE(WEBASSEMBLY)

JSC::Wasm::enableFastMemory();

#endif

#if ENABLE(INTELLIGENT_TRACKING_PREVENTION) && !RELEASE_LOG_DISABLED

WebResourceLoadObserver::setShouldLogUserInteraction(parameters.shouldLogUserInteraction);

#endif

#if PLATFORM(COCOA)

if (m_processType == ProcessType::PrewarmedWebContent)

prewarmGlobally();

#endif

WEBPROCESS_RELEASE_LOG(Process, "initializeWebProcess: Presenting processPID=%d", WebCore::presentingApplicationPID());

}

void WebProcess::setWebsiteDataStoreParameters(WebProcessDataStoreParameters&& parameters)

{

ASSERT(!m_sessionID);

m_sessionID = parameters.sessionID;

// FIXME: This should be constructed per data store, not per process.

m_applicationCacheStorage = ApplicationCacheStorage::create(parameters.applicationCacheDirectory, parameters.applicationCacheFlatFileSubdirectoryName);

#if PLATFORM(IOS_FAMILY)

m_applicationCacheStorage->setDefaultOriginQuota(25ULL * 1024 * 1024);

#endif

#if ENABLE(VIDEO)

if (!parameters.mediaCacheDirectory.isEmpty())

WebCore::HTMLMediaElement::setMediaCacheDirectory(parameters.mediaCacheDirectory);

#endif

#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)

if (!parameters.modelElementCacheDirectory.isEmpty())

ARKitInlinePreviewModelPlayerMac::setModelElementCacheDirectory(parameters.modelElementCacheDirectory);

#endif

setResourceLoadStatisticsEnabled(parameters.resourceLoadStatisticsEnabled);

#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)

m_thirdPartyCookieBlockingMode = parameters.thirdPartyCookieBlockingMode;

if (parameters.resourceLoadStatisticsEnabled) {

if (!ResourceLoadObserver::sharedIfExists())

ResourceLoadObserver::setShared(*new WebResourceLoadObserver(parameters.sessionID.isEphemeral() ? WebCore::ResourceLoadStatistics::IsEphemeral::Yes : WebCore::ResourceLoadStatistics::IsEphemeral::No));

ResourceLoadObserver::shared().setDomainsWithUserInteraction(WTFMove(parameters.domainsWithUserInteraction));

if (!parameters.sessionID.isEphemeral())

ResourceLoadObserver::shared().setDomainsWithCrossPageStorageAccess(WTFMove(parameters.domainsWithStorageAccessQuirk), [] { });

}

#endif

for (auto& supplement : m_supplements.values())

supplement->setWebsiteDataStore(parameters);

platformSetWebsiteDataStoreParameters(WTFMove(parameters));

ensureNetworkProcessConnection();

}

bool WebProcess::areAllPagesSuspended() const

{

for (auto& page : m_pageMap.values()) {

if (!page->isSuspended())

return false;

}

return true;

}

void WebProcess::setHasSuspendedPageProxy(bool hasSuspendedPageProxy)

{

ASSERT(m_hasSuspendedPageProxy != hasSuspendedPageProxy);

m_hasSuspendedPageProxy = hasSuspendedPageProxy;

}

void WebProcess::setIsInProcessCache(bool isInProcessCache)

{

#if PLATFORM(COCOA)

if (isInProcessCache) {

ASSERT(m_processType == ProcessType::WebContent);

m_processType = ProcessType::CachedWebContent;

} else {

ASSERT(m_processType == ProcessType::CachedWebContent);

m_processType = ProcessType::WebContent;

}

updateProcessName(IsInProcessInitialization::No);

IPC::AccessibilityProcessSuspendedNotification(isInProcessCache);

#else

UNUSED_PARAM(isInProcessCache);

#endif

}

void WebProcess::markIsNoLongerPrewarmed()

{

#if PLATFORM(COCOA)

ASSERT(m_processType == ProcessType::PrewarmedWebContent);

m_processType = ProcessType::WebContent;

updateProcessName(IsInProcessInitialization::No);

#endif

}

void WebProcess::prewarmGlobally()

{

if (MemoryPressureHandler::singleton().isUnderMemoryPressure()) {

RELEASE_LOG(PerformanceLogging, "WebProcess::prewarmGlobally: Not prewarming because the system in under memory pressure");

return;

}

WebCore::ProcessWarming::prewarmGlobally();

}

void WebProcess::prewarmWithDomainInformation(const WebCore::PrewarmInformation& prewarmInformation)

{

WebCore::ProcessWarming::prewarmWithInformation(prewarmInformation);

}

void WebProcess::registerURLSchemeAsEmptyDocument(const String& urlScheme)

{

LegacySchemeRegistry::registerURLSchemeAsEmptyDocument(urlScheme);

}

void WebProcess::registerURLSchemeAsSecure(const String& urlScheme) const

{

LegacySchemeRegistry::registerURLSchemeAsSecure(urlScheme);

}

void WebProcess::registerURLSchemeAsBypassingContentSecurityPolicy(const String& urlScheme) const

{

LegacySchemeRegistry::registerURLSchemeAsBypassingContentSecurityPolicy(urlScheme);

}

void WebProcess::setDomainRelaxationForbiddenForURLScheme(const String& urlScheme) const

{

LegacySchemeRegistry::setDomainRelaxationForbiddenForURLScheme(true, urlScheme);

}

void WebProcess::registerURLSchemeAsLocal(const String& urlScheme) const

{

LegacySchemeRegistry::registerURLSchemeAsLocal(urlScheme);

}

void WebProcess::registerURLSchemeAsNoAccess(const String& urlScheme) const

{

LegacySchemeRegistry::registerURLSchemeAsNoAccess(urlScheme);

}

void WebProcess::registerURLSchemeAsDisplayIsolated(const String& urlScheme) const

{

LegacySchemeRegistry::registerURLSchemeAsDisplayIsolated(urlScheme);

}

void WebProcess::registerURLSchemeAsCORSEnabled(const String& urlScheme)

{

LegacySchemeRegistry::registerURLSchemeAsCORSEnabled(urlScheme);

ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterURLSchemesAsCORSEnabled({ urlScheme }), 0);

}

void WebProcess::registerURLSchemeAsAlwaysRevalidated(const String& urlScheme) const

{

LegacySchemeRegistry::registerURLSchemeAsAlwaysRevalidated(urlScheme);

}

void WebProcess::registerURLSchemeAsCachePartitioned(const String& urlScheme) const

{

LegacySchemeRegistry::registerURLSchemeAsCachePartitioned(urlScheme);

}

void WebProcess::registerURLSchemeAsCanDisplayOnlyIfCanRequest(const String& urlScheme) const

{

LegacySchemeRegistry::registerAsCanDisplayOnlyIfCanRequest(urlScheme);

}

void WebProcess::setDefaultRequestTimeoutInterval(double timeoutInterval)

{

ResourceRequest::setDefaultTimeoutInterval(timeoutInterval);

}

void WebProcess::setAlwaysUsesComplexTextCodePath(bool alwaysUseComplexText)

{

WebCore::FontCascade::setCodePath(alwaysUseComplexText ? WebCore::FontCascade::CodePath::Complex : WebCore::FontCascade::CodePath::Auto);

}

void WebProcess::setShouldUseFontSmoothing(bool useFontSmoothing)

{

WebCore::FontCascade::setShouldUseSmoothing(useFontSmoothing);

}

void WebProcess::userPreferredLanguagesChanged(const Vector<String>& languages) const

{

LOG_WITH_STREAM(Language, stream << "The web process's userPreferredLanguagesChanged: " << languages);

overrideUserPreferredLanguages(languages);

}

void WebProcess::fullKeyboardAccessModeChanged(bool fullKeyboardAccessEnabled)

{

m_fullKeyboardAccessEnabled = fullKeyboardAccessEnabled;

}

void WebProcess::setCacheModel(CacheModel cacheModel)

{

if (m_hasSetCacheModel && (cacheModel == m_cacheModel))

return;

m_hasSetCacheModel = true;

m_cacheModel = cacheModel;

unsigned cacheTotalCapacity = 0;

unsigned cacheMinDeadCapacity = 0;

unsigned cacheMaxDeadCapacity = 0;

Seconds deadDecodedDataDeletionInterval;

unsigned backForwardCacheSize = 0;

calculateMemoryCacheSizes(cacheModel, cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval, backForwardCacheSize);

auto& memoryCache = MemoryCache::singleton();

memoryCache.setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);

memoryCache.setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);

BackForwardCache::singleton().setMaxSize(backForwardCacheSize);

platformSetCacheModel(cacheModel);

}

WebPage* WebProcess::focusedWebPage() const

{

for (auto& page : m_pageMap.values()) {

if (page->windowAndWebPageAreFocused())

return page.get();

}

return 0;

}

WebPage* WebProcess::webPage(PageIdentifier pageID) const

{

return m_pageMap.get(pageID);

}

void WebProcess::createWebPage(PageIdentifier pageID, WebPageCreationParameters&& parameters)

{

// It is necessary to check for page existence here since during a window.open() (or targeted

// link) the WebPage gets created both in the synchronous handler and through the normal way.

auto result = m_pageMap.add(pageID, nullptr);

if (result.isNewEntry) {

ASSERT(!result.iterator->value);

auto page = WebPage::create(pageID, WTFMove(parameters));

result.iterator->value = page.ptr();

#if ENABLE(GPU_PROCESS)

if (m_gpuProcessConnection)

page->gpuProcessConnectionDidBecomeAvailable(*m_gpuProcessConnection);

#endif

// Balanced by an enableTermination in removeWebPage.

disableTermination();

updateCPULimit();

#if OS(LINUX)

RealTimeThreads::singleton().setEnabled(hasVisibleWebPage());

#endif

} else

result.iterator->value->reinitializeWebPage(WTFMove(parameters));

ASSERT(result.iterator->value);

}

void WebProcess::removeWebPage(PageIdentifier pageID)

{

ASSERT(m_pageMap.contains(pageID));

flushResourceLoadStatistics();

pageWillLeaveWindow(pageID);

m_pageMap.remove(pageID);

enableTermination();

updateCPULimit();

#if OS(LINUX)

RealTimeThreads::singleton().setEnabled(hasVisibleWebPage());

#endif

}

bool WebProcess::shouldTerminate()

{

ASSERT(m_pageMap.isEmpty());

// FIXME: the ShouldTerminate message should also send termination parameters, such as any session cookies that need to be preserved.

bool shouldTerminate = false;

if (parentProcessConnection()->sendSync(Messages::WebProcessProxy::ShouldTerminate(), Messages::WebProcessProxy::ShouldTerminate::Reply(shouldTerminate), 0)

&& !shouldTerminate)

return false;

return true;

}

void WebProcess::terminate()

{

#ifndef NDEBUG

// These are done in an attempt to reduce LEAK output.

GCController::singleton().garbageCollectNow();

FontCache::forCurrentThread().invalidate();

MemoryCache::singleton().setDisabled(true);

#endif

m_webConnection->invalidate();

m_webConnection = nullptr;

platformTerminate();

AuxiliaryProcess::terminate();

}

bool WebProcess::didReceiveSyncMessage(IPC::Connection& connection, IPC::Decoder& decoder, UniqueRef<IPC::Encoder>& replyEncoder)

{

if (messageReceiverMap().dispatchSyncMessage(connection, decoder, replyEncoder))

return true;

return false;

}

void WebProcess::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)

{

if (messageReceiverMap().dispatchMessage(connection, decoder))

return;

if (decoder.messageReceiverName() == Messages::WebProcess::messageReceiverName()) {

didReceiveWebProcessMessage(connection, decoder);

return;

}

if (decoder.messageReceiverName() == Messages::AuxiliaryProcess::messageReceiverName()) {

AuxiliaryProcess::didReceiveMessage(connection, decoder);

return;

}

#if ENABLE(SERVICE_WORKER)

// FIXME: Remove?

if (decoder.messageReceiverName() == Messages::WebSWContextManagerConnection::messageReceiverName()) {

ASSERT(SWContextManager::singleton().connection());

if (auto* contextManagerConnection = SWContextManager::singleton().connection())

static_cast<WebSWContextManagerConnection&>(*contextManagerConnection).didReceiveMessage(connection, decoder);

return;

}

#endif

LOG_ERROR("Unhandled web process message '%s' (destination: %" PRIu64 " pid: %d)", description(decoder.messageName()), decoder.destinationID(), static_cast<int>(getCurrentProcessID()));

}

WebFrame* WebProcess::webFrame(FrameIdentifier frameID) const

{

return m_frameMap.get(frameID);

}

Vector<WebFrame*> WebProcess::webFrames() const

{

return copyToVector(m_frameMap.values());

}

void WebProcess::addWebFrame(FrameIdentifier frameID, WebFrame* frame)

{

m_frameMap.set(frameID, frame);

}

void WebProcess::removeWebFrame(FrameIdentifier frameID)

{

m_frameMap.remove(frameID);

// We can end up here after our connection has closed when WebCore's frame life-support timer

// fires when the application is shutting down. There's no need (and no way) to update the UI

// process in this case.

if (!parentProcessConnection())

return;

parentProcessConnection()->send(Messages::WebProcessProxy::DidDestroyFrame(frameID), 0);

}

WebPageGroupProxy* WebProcess::webPageGroup(PageGroup* pageGroup)

{

for (auto& page : m_pageGroupMap.values()) {

if (page->corePageGroup() == pageGroup)

return page.get();

}

return 0;

}

WebPageGroupProxy* WebProcess::webPageGroup(PageGroupIdentifier pageGroupID)

{

return m_pageGroupMap.get(pageGroupID);

}

WebPageGroupProxy* WebProcess::webPageGroup(const WebPageGroupData& pageGroupData)

{

auto result = m_pageGroupMap.add(pageGroupData.pageGroupID, nullptr);

if (result.isNewEntry) {

ASSERT(!result.iterator->value);

result.iterator->value = WebPageGroupProxy::create(pageGroupData);

}

return result.iterator->value.get();

}

static uint64_t nextUserGestureTokenIdentifier()

{

static uint64_t identifier = 1;

return identifier++;

}

uint64_t WebProcess::userGestureTokenIdentifier(RefPtr<UserGestureToken> token)

{

if (!token || !token->processingUserGesture())

return 0;

auto result = m_userGestureTokens.ensure(token.get(), [] { return nextUserGestureTokenIdentifier(); });

if (result.isNewEntry) {

result.iterator->key->addDestructionObserver([] (UserGestureToken& tokenBeingDestroyed) {

WebProcess::singleton().userGestureTokenDestroyed(tokenBeingDestroyed);

});

}

return result.iterator->value;

}

void WebProcess::userGestureTokenDestroyed(UserGestureToken& token)

{

auto identifier = m_userGestureTokens.take(&token);

parentProcessConnection()->send(Messages::WebProcessProxy::DidDestroyUserGestureToken(identifier), 0);

}

void WebProcess::isJITEnabled(CompletionHandler<void(bool)>&& completionHandler)

{

completionHandler(JSC::Options::useJIT());