{

// If the connection has been closed and we haven't responded in the main thread for 10 seconds the process will exit forcibly.

static const auto watchdogDelay = 10_s;

WorkQueue::create("WebKit.WebProcess.WatchDogQueue"_s)->dispatchAfter(watchdogDelay, [] {

// We use g_error() here to cause a crash and allow debugging this unexpected late exit.

g_error("WebProcess didn't exit as expected after the UI process connection was closed");

});

{

WTF::setProcessPrivileges({ });

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

platformInitializeProcess(parameters);

updateCPULimit();

{

AuxiliaryProcess::initializeConnection(connection);

#if PLATFORM(GTK) || PLATFORM(WPE)

IPC::Connection::DidCloseOnConnectionWorkQueueCallback callExitCallback = crashAfter10Seconds;

#else

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

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

IPC::Connection::DidCloseOnConnectionWorkQueueCallback callExitCallback = callExit;

#endif

connection->setDidCloseOnConnectionWorkQueueCallback(callExitCallback);

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

{

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

});

{

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

// 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_allowExitOnMemoryPressure && (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_allowExitOnMemoryPressure ? WebCore::MaintainBackForwardCache::No : WebCore::MaintainBackForwardCache::Yes;

auto maintainMemoryCache = (m_allowExitOnMemoryPressure || !m_hasSuspendedPageProxy) ? WebCore::MaintainMemoryCache::No : WebCore::MaintainMemoryCache::Yes;

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

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

page->releaseMemory(critical);

});

#if ENABLE(PERIODIC_MEMORY_MONITOR)

if (auto pollInterval = parameters.memoryFootprintPollIntervalForTesting)

memoryPressureHandler.setMemoryFootprintPollIntervalForTesting(pollInterval);

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.setMemoryFootprintNotificationThresholds(WTFMove(parameters.memoryFootprintNotificationThresholds), [this](size_t footprint) {

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

});

#endif

memoryPressureHandler.setMemoryPressureStatusChangedCallback([this]() {

if (parentProcessConnection())

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

});

memoryPressureHandler.setDidExceedProcessMemoryLimitCallback([this](WTF::ProcessMemoryLimit limit) {

if (limit == WTF::ProcessMemoryLimit::Warning && !m_loggedProcessLimitWarningMemoryStatistics) {

m_loggedProcessLimitWarningMemoryStatistics = true;

scheduleLogMemoryStatistics(LogMemoryStatisticsReason::WarningMemoryPressureNotification);

} else if (limit == WTF::ProcessMemoryLimit::Critical && !m_loggedProcessLimitCriticalMemoryStatistics) {

m_loggedProcessLimitCriticalMemoryStatistics = true;

scheduleLogMemoryStatistics(LogMemoryStatisticsReason::CriticalMemoryPressureNotification);

}

});

memoryPressureHandler.install();

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

WebCore::logMemoryStatistics(LogMemoryStatisticsReason::DebugNotification);

});

}

#if !RELEASE_LOG_DISABLED

PAL::registerNotifyCallback("com.apple.WebKit.logPageState"_s, [this] {

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

int64_t loadCommitTime = 0;

#if USE(OS_STATE)

loadCommitTime = static_cast<int64_t>(page->loadCommitTime().secondsSinceEpoch().seconds());

#endif

WTF::TextStream activityStateStream(WTF::TextStream::LineMode::SingleLine);

activityStateStream << page->activityState();

RELEASE_LOG(ActivityState, "WebPage %p - load_time: %" PRId64 ", visible: %d, throttleable: %d , suspended: %d , websam_state: %" PUBLIC_LOG_STRING ", activity_state: %" PUBLIC_LOG_STRING ", url: %" PRIVATE_LOG_STRING, page.get(), loadCommitTime, page->isVisible(), page->isThrottleable(), page->isSuspended(), MemoryPressureHandler::processStateDescription().characters(), activityStateStream.release().utf8().data(), page->mainWebFrame().url().string().utf8().data());

}

});

#endif

SandboxExtension::consumePermanently(parameters.additionalSandboxExtensionHandles);

if (!parameters.injectedBundlePath.isEmpty())

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

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

supplement->initialize(parameters);

#if ENABLE(GPU_PROCESS) && ENABLE(VIDEO)

m_remoteMediaPlayerManager->initialize(parameters);

#endif

setCacheModel(parameters.cacheModel);

if (!parameters.timeZoneOverride.isEmpty())

setTimeZoneOverride(parameters.timeZoneOverride);

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

#if ENABLE(WK_WEB_EXTENSIONS)

for (auto& scheme : parameters.urlSchemesRegisteredAsWebExtensions)

WebExtensionMatchPattern::registerCustomURLScheme(scheme);

#endif

setDefaultRequestTimeoutInterval(parameters.defaultRequestTimeoutInterval);

setBackForwardCacheCapacity(parameters.backForwardCacheCapacity);

setAlwaysUsesComplexTextCodePath(parameters.shouldAlwaysUseComplexTextCodePath);

setDisableFontSubpixelAntialiasingForTesting(parameters.disableFontSubpixelAntialiasingForTesting);

setMemoryCacheDisabled(parameters.memoryCacheDisabled);

WebCore::DeprecatedGlobalSettings::setAttrStyleEnabled(parameters.attrStyleEnabled);

commonVM().setGlobalConstRedeclarationShouldThrow(parameters.shouldThrowExceptionForGlobalConstantRedeclaration);

ScriptExecutionContext::setCrossOriginMode(parameters.crossOriginMode);

m_isLockdownModeEnabled = parameters.isLockdownModeEnabled;

DeprecatedGlobalSettings::setArePDFImagesEnabled(!m_isLockdownModeEnabled);

#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

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

SharedWorkerProvider::setSharedProvider(WebSharedWorkerProvider::singleton());

#if !RELEASE_LOG_DISABLED

WebResourceLoadObserver::setShouldLogUserInteraction(parameters.shouldLogUserInteraction);

#endif

#if PLATFORM(COCOA)

if (m_processType == ProcessType::PrewarmedWebContent)

prewarmGlobally();

#endif

updateStorageAccessUserAgentStringQuirks(WTFMove(parameters.storageAccessUserAgentStringQuirksData));

updateDomainsWithStorageAccessQuirks(WTFMove(parameters.storageAccessPromptQuirksDomains));

#if ENABLE(GAMEPAD)

// Web processes need to periodically notify the UI process of gamepad access at least as frequently

// as the WebPageProxy::gamepadsRecentlyAccessedThreshold value.

// 3-times-as-often seems like it will guarantee proper behavior for almost all web pages.

WebCore::NavigatorGamepad::setGamepadsRecentlyAccessedThreshold(WebPageProxy::gamepadsRecentlyAccessedThreshold / 3);

#endif

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

{

ASSERT(!m_sessionID);

m_sessionID = parameters.sessionID;

#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

setTrackingPreventionEnabled(parameters.trackingPreventionEnabled);

m_thirdPartyCookieBlockingMode = parameters.thirdPartyCookieBlockingMode;

if (parameters.trackingPreventionEnabled) {

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), [] { });

}

m_mediaKeysStorageDirectory = parameters.mediaKeyStorageDirectory;

m_mediaKeysStorageSalt = parameters.mediaKeysStorageSalt;

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

supplement->setWebsiteDataStore(parameters);

platformSetWebsiteDataStoreParameters(WTFMove(parameters));

ensureNetworkProcessConnection();

{

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

if (!page->isSuspended())

return false;

}

return true;

{

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

if (page->isWebTransportEnabled()) {

m_isWebTransportEnabled = true;

return;

}

}

m_isWebTransportEnabled = false;

{

ASSERT(m_hasSuspendedPageProxy != hasSuspendedPageProxy);

m_hasSuspendedPageProxy = hasSuspendedPageProxy;

{

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

accessibilityRelayProcessSuspended(isInProcessCache);

#else

UNUSED_PARAM(isInProcessCache);

#endif

completionHandler();

{

#if PLATFORM(COCOA)

ASSERT(m_processType == ProcessType::PrewarmedWebContent);

m_processType = ProcessType::WebContent;

updateProcessName(IsInProcessInitialization::No);

#endif

{

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

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

return;

}

WebCore::ProcessWarming::prewarmGlobally();

{

LegacySchemeRegistry::registerURLSchemeAsCORSEnabled(urlScheme);

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

{

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

overrideUserPreferredLanguages(languages);

{

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

{

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

m_hasEverHadAnyWebPages = true;

if (result.isNewEntry) {

ASSERT(!result.iterator->value);

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

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

#if ENABLE(GPU_PROCESS)

if (RefPtr gpuProcessConnection = m_gpuProcessConnection)

page->gpuProcessConnectionDidBecomeAvailable(*gpuProcessConnection);

#endif

// Balanced by an enableTermination in removeWebPage.

disableTermination();

updateCPULimit();

updateIsWebTransportEnabled();

#if OS(LINUX)

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

#endif

} else

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

if (m_hasPendingAccessibilityUnsuspension) {

m_hasPendingAccessibilityUnsuspension = false;

accessibilityRelayProcessSuspended(false);

}

ASSERT(result.iterator->value);

{

ASSERT(m_pageMap.contains(pageID));

flushResourceLoadStatistics();

pageWillLeaveWindow(pageID);

m_pageMap.remove(pageID);

enableTermination();

updateCPULimit();

updateIsWebTransportEnabled();

#if OS(LINUX)

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

#endif

{

ASSERT(m_pageMap.isEmpty());

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

auto sendResult = parentProcessConnection()->sendSync(Messages::WebProcessProxy::ShouldTerminate(), 0);

auto [shouldTerminate] = sendResult.takeReplyOr(true);

return shouldTerminate;

{

#ifndef NDEBUG

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

GCController::singleton().garbageCollectNow();

FontCache::invalidateAllFontCaches();

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

#endif

m_webConnection->invalidate();

m_webConnection = nullptr;

platformTerminate();

AuxiliaryProcess::terminate();

{

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

return true;

return false;

{

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 (decoder.messageReceiverName() == Messages::WebSWContextManagerConnection::messageReceiverName()) {

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

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

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

return;

}

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

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

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

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

return;

}

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

{

#if ENABLE(VIDEO)

FileSystem::markPurgeable(WebCore::HTMLMediaElement::mediaCacheDirectory());

#endif