#include "config.h"

#include "WebPage.h"

#include "APIArray.h"

#include "APIGeometry.h"

#include "APIInjectedBundleEditorClient.h"

#include "APIInjectedBundleFormClient.h"

#include "APIInjectedBundlePageContextMenuClient.h"

#include "APIInjectedBundlePageLoaderClient.h"

#include "APIInjectedBundlePageResourceLoadClient.h"

#include "APIInjectedBundlePageUIClient.h"

#include "Connection.h"

#include "ContentAsStringIncludesChildFrames.h"

#include "DragControllerAction.h"

#include "DrawingArea.h"

#include "DrawingAreaMessages.h"

#include "EditorState.h"

#include "EventDispatcher.h"

#include "FindController.h"

#include "FocusedElementInformation.h"

#include "FormDataReference.h"

#include "FrameTreeNodeData.h"

#include "GeolocationPermissionRequestManager.h"

#include "GoToBackForwardItemParameters.h"

#include "InjectUserScriptImmediately.h"

#include "InjectedBundle.h"

#include "InjectedBundleScriptWorld.h"

#include "LibWebRTCCodecs.h"

#include "LibWebRTCProvider.h"

#include "LoadParameters.h"

#include "Logging.h"

#include "MediaKeySystemPermissionRequestManager.h"

#include "MediaRecorderProvider.h"

#include "MessageSenderInlines.h"

#include "NetworkConnectionToWebProcessMessages.h"

#include "NetworkProcessConnection.h"

#include "NotificationPermissionRequestManager.h"

#include "PageBanner.h"

#include "PluginView.h"

#include "PolicyDecision.h"

#include "PrintInfo.h"

#include "ProvisionalFrameCreationParameters.h"

#include "RemoteNativeImageBackendProxy.h"

#include "RemoteRenderingBackendProxy.h"

#include "RemoteScrollingCoordinator.h"

#include "RemoteWebInspectorUI.h"

#include "RemoteWebInspectorUIMessages.h"

#include "SessionState.h"

#include "SessionStateConversion.h"

#include "ShareableBitmapUtilities.h"

#include "SharedBufferReference.h"

#include "TextRecognitionUpdateResult.h"

#include "UserMediaPermissionRequestManager.h"

#include "ViewGestureGeometryCollector.h"

#include "VisitedLinkTableController.h"

#include "WKBundleAPICast.h"

#include "WKRetainPtr.h"

#include "WKSharedAPICast.h"

#include "WebAlternativeTextClient.h"

#include "WebAttachmentElementClient.h"

#include "WebBackForwardListItem.h"

#include "WebBackForwardListProxy.h"

#include "WebBadgeClient.h"

#include "WebBroadcastChannelRegistry.h"

#include "WebCacheStorageProvider.h"

#include "WebChromeClient.h"

#include "WebColorChooser.h"

#include "WebContextMenu.h"

#include "WebContextMenuClient.h"

#include "WebCookieJar.h"

#include "WebCoreArgumentCoders.h"

#include "WebCryptoClient.h"

#include "WebDataListSuggestionPicker.h"

#include "WebDatabaseProvider.h"

#include "WebDateTimeChooser.h"

#include "WebDiagnosticLoggingClient.h"

#include "WebDragClient.h"

#include "WebEditorClient.h"

#include "WebEventConversion.h"

#include "WebEventFactory.h"

#include "WebFoundTextRange.h"

#include "WebFoundTextRangeController.h"

#include "WebFrame.h"

#include "WebFullScreenManager.h"

#include "WebFullScreenManagerMessages.h"

#include "WebGamepadProvider.h"

#include "WebGeolocationClient.h"

#include "WebHistoryItemClient.h"

#include "WebHitTestResultData.h"

#include "WebImage.h"

#include "WebInspector.h"

#include "WebInspectorClient.h"

#include "WebInspectorMessages.h"

#include "WebInspectorUI.h"

#include "WebInspectorUIMessages.h"

#include "WebKeyboardEvent.h"

#include "WebLoaderStrategy.h"

#include "WebLocalFrameLoaderClient.h"

#include "WebMediaKeyStorageManager.h"

#include "WebMediaKeySystemClient.h"

#include "WebMediaStrategy.h"

#include "WebModelPlayerProvider.h"

#include "WebMouseEvent.h"

#include "WebNotificationClient.h"

#include "WebOpenPanelResultListener.h"

#include "WebPageCreationParameters.h"

#include "WebPageGroupProxy.h"

#include "WebPageInlines.h"

#include "WebPageInspectorTargetController.h"

#include "WebPageMessages.h"

#include "WebPageOverlay.h"

#include "WebPageProxyMessages.h"

#include "WebPaymentCoordinator.h"

#include "WebPerformanceLoggingClient.h"

#include "WebPluginInfoProvider.h"

#include "WebPopupMenu.h"

#include "WebPreferencesDefinitions.h"

#include "WebPreferencesKeys.h"

#include "WebPreferencesStore.h"

#include "WebProcess.h"

#include "WebProcessPoolMessages.h"

#include "WebProcessProxyMessages.h"

#include "WebProgressTrackerClient.h"

#include "WebRemoteFrameClient.h"

#include "WebScreenOrientationManager.h"

#include "WebServiceWorkerProvider.h"

#include "WebSocketProvider.h"

#include "WebSpeechRecognitionProvider.h"

#include "WebSpeechSynthesisClient.h"

#include "WebStorageNamespaceProvider.h"

#include "WebStorageProvider.h"

#include "WebTouchEvent.h"

#include "WebURLSchemeHandlerProxy.h"

#include "WebUndoStep.h"

#include "WebUserContentController.h"

#include "WebUserMediaClient.h"

#include "WebValidationMessageClient.h"

#include "WebWheelEvent.h"

#include "WebsiteDataStoreParameters.h"

#include "WebsitePoliciesData.h"

#include <JavaScriptCore/APICast.h>

#include <JavaScriptCore/JSCInlines.h>

#include <JavaScriptCore/JSCJSValue.h>

#include <JavaScriptCore/JSLock.h>

#include <JavaScriptCore/ProfilerDatabase.h>

#include <JavaScriptCore/SamplingProfiler.h>

#include <WebCore/AppHighlight.h>

#include <WebCore/ArchiveResource.h>

#include <WebCore/BackForwardCache.h>

#include <WebCore/BackForwardController.h>

#include <WebCore/BitmapImage.h>

#include <WebCore/CachedPage.h>

#include <WebCore/Chrome.h>

#include <WebCore/CommonVM.h>

#include <WebCore/ContactsRequestData.h>

#include <WebCore/ContextMenuController.h>

#include <WebCore/CrossOriginEmbedderPolicy.h>

#include <WebCore/CrossOriginOpenerPolicy.h>

#include <WebCore/DOMPasteAccess.h>

#include <WebCore/DataTransfer.h>

#include <WebCore/DatabaseManager.h>

#include <WebCore/DeprecatedGlobalSettings.h>

#include <WebCore/Document.h>

#include <WebCore/DocumentFragment.h>

#include <WebCore/DocumentInlines.h>

#include <WebCore/DocumentLoader.h>

#include <WebCore/DocumentMarkerController.h>

#include <WebCore/DocumentStorageAccess.h>

#include <WebCore/DragController.h>

#include <WebCore/DragData.h>

#include <WebCore/Editing.h>

#include <WebCore/Editor.h>

#include <WebCore/ElementIterator.h>

#include <WebCore/ElementTargetingController.h>

#include <WebCore/EventHandler.h>

#include <WebCore/EventNames.h>

#include <WebCore/ExceptionCode.h>

#include <WebCore/File.h>

#include <WebCore/FocusController.h>

#include <WebCore/FontAttributeChanges.h>

#include <WebCore/FontAttributes.h>

#include <WebCore/FormState.h>

#include <WebCore/FragmentDirectiveParser.h>

#include <WebCore/FragmentDirectiveRangeFinder.h>

#include <WebCore/FrameLoadRequest.h>

#include <WebCore/FrameLoaderTypes.h>

#include <WebCore/FullscreenManager.h>

#include <WebCore/GeometryUtilities.h>

#include <WebCore/HTMLAttachmentElement.h>

#include <WebCore/HTMLFormElement.h>

#include <WebCore/HTMLImageElement.h>

#include <WebCore/HTMLInputElement.h>

#include <WebCore/HTMLPlugInElement.h>

#include <WebCore/HTMLSelectElement.h>

#include <WebCore/HTMLTextFormControlElement.h>

#include <WebCore/HTTPParsers.h>

#include <WebCore/HTTPStatusCodes.h>

#include <WebCore/HandleUserInputEventResult.h>

#include <WebCore/Highlight.h>

#include <WebCore/HighlightRegistry.h>

#include <WebCore/HistoryController.h>

#include <WebCore/HistoryItem.h>

#include <WebCore/HitTestResult.h>

#include <WebCore/ImageAnalysisQueue.h>

#include <WebCore/ImageOverlay.h>

#include <WebCore/InspectorController.h>

#include <WebCore/JSDOMExceptionHandling.h>

#include <WebCore/KeyboardEvent.h>

#include <WebCore/LegacySchemeRegistry.h>

#include <WebCore/LocalFrame.h>

#include <WebCore/LocalFrameView.h>

#include <WebCore/LocalizedStrings.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/MouseEvent.h>

#include <WebCore/NavigationScheduler.h>

#include <WebCore/NotImplemented.h>

#include <WebCore/NotificationController.h>

#include <WebCore/OriginAccessPatterns.h>

#include <WebCore/Page.h>

#include <WebCore/PageConfiguration.h>

#include <WebCore/PingLoader.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/PlatformMediaSessionManager.h>

#include <WebCore/PlatformMouseEvent.h>

#include <WebCore/PlatformStrategies.h>

#include <WebCore/PluginDocument.h>

#include <WebCore/PointerCaptureController.h>

#include <WebCore/PrintContext.h>

#include <WebCore/ProcessCapabilities.h>

#include <WebCore/PromisedAttachmentInfo.h>

#include <WebCore/Quirks.h>

#include <WebCore/Range.h>

#include <WebCore/RegistrableDomain.h>

#include <WebCore/RemoteDOMWindow.h>

#include <WebCore/RemoteFrame.h>

#include <WebCore/RemoteFrameClient.h>

#include <WebCore/RemoteFrameView.h>

#include <WebCore/RemoteUserInputEventData.h>

#include <WebCore/RenderImage.h>

#include <WebCore/RenderLayer.h>

#include <WebCore/RenderTheme.h>

#include <WebCore/RenderTreeAsText.h>

#include <WebCore/RenderVideo.h>

#include <WebCore/RenderView.h>

#include <WebCore/Report.h>

#include <WebCore/ReportingScope.h>

#include <WebCore/ResourceLoadStatistics.h>

#include <WebCore/ResourceRequest.h>

#include <WebCore/ResourceResponse.h>

#include <WebCore/RunJavaScriptParameters.h>

#include <WebCore/SWClientConnection.h>

#include <WebCore/ScriptController.h>

#include <WebCore/ScriptDisallowedScope.h>

#include <WebCore/SecurityPolicy.h>

#include <WebCore/SelectionRestorationMode.h>

#include <WebCore/SerializedScriptValue.h>

#include <WebCore/Settings.h>

#include <WebCore/ShadowRoot.h>

#include <WebCore/ShareableBitmap.h>

#include <WebCore/SharedBuffer.h>

#include <WebCore/StaticRange.h>

#include <WebCore/StyleProperties.h>

#include <WebCore/SubframeLoader.h>

#include <WebCore/SubresourceLoader.h>

#include <WebCore/SubstituteData.h>

#include <WebCore/TextExtraction.h>

#include <WebCore/TextIterator.h>

#include <WebCore/TextRecognitionOptions.h>

#include <WebCore/TranslationContextMenuInfo.h>

#include <WebCore/UserContentURLPattern.h>

#include <WebCore/UserGestureIndicator.h>

#include <WebCore/UserScript.h>

#include <WebCore/UserStyleSheet.h>

#include <WebCore/UserTypingGestureIndicator.h>

#include <WebCore/ViolationReportType.h>

#include <WebCore/VisiblePosition.h>

#include <WebCore/VisibleUnits.h>

#include <WebCore/WritingDirection.h>

#include <WebCore/markup.h>

#include <pal/SessionID.h>

#include <wtf/ProcessID.h>

#include <wtf/RunLoop.h>

#include <wtf/Scope.h>

#include <wtf/SetForScope.h>

#include <wtf/SystemTracing.h>

#include <wtf/text/TextStream.h>

#if ENABLE(APP_HIGHLIGHTS)

#include <WebCore/AppHighlightStorage.h>

#endif

#if ENABLE(DATA_DETECTION)

#include "DataDetectionResult.h"

#endif

#if ENABLE(MHTML)

#include <WebCore/MHTMLArchive.h>

#endif

#if ENABLE(POINTER_LOCK)

#include <WebCore/PointerLockController.h>

#endif

#if PLATFORM(COCOA)

#include "DefaultWebBrowserChecks.h"

#include "InsertTextOptions.h"

#include "PlaybackSessionManager.h"

#include "RemoteLayerTreeDrawingArea.h"

#include "RemoteLayerTreeTransaction.h"

#include "RemoteObjectRegistryMessages.h"

#include "TextCheckingControllerProxy.h"

#include "VideoPresentationManager.h"

#include "WKStringCF.h"

#include "WebRemoteObjectRegistry.h"

#include <WebCore/LegacyWebArchive.h>

#include <WebCore/TextPlaceholderElement.h>

#include <pal/spi/cg/ImageIOSPI.h>

#include <wtf/MachSendRight.h>

#include <wtf/spi/darwin/SandboxSPI.h>

#endif

#if PLATFORM(GTK)

#include "WebPrintOperationGtk.h"

#include <WebCore/SelectionData.h>

#include <gtk/gtk.h>

#endif

#if PLATFORM(IOS_FAMILY)

#include "InteractionInformationAtPosition.h"

#include "InteractionInformationRequest.h"

#include "WebAutocorrectionContext.h"

#include <CoreGraphics/CoreGraphics.h>

#include <WebCore/Icon.h>

#include <pal/spi/cf/CoreTextSPI.h>

#endif

#if PLATFORM(MAC)

#include <WebCore/LocalDefaultSystemAppearance.h>

#include <pal/spi/cf/CFUtilitiesSPI.h>

#endif

#ifndef NDEBUG

#include <wtf/RefCountedLeakCounter.h>

#endif

#if ENABLE(DATA_DETECTION)

#include <WebCore/DataDetection.h>

#include <WebCore/DataDetectionResultsStorage.h>

#endif

#if ENABLE(MEDIA_STREAM) && USE(GSTREAMER)

#include <WebCore/MockRealtimeMediaSourceCenter.h>

#endif

#if ENABLE(WEB_AUTHN)

#include "WebAuthenticatorCoordinator.h"

#include <WebCore/AuthenticatorCoordinator.h>

#endif

#if PLATFORM(IOS_FAMILY) && ENABLE(DEVICE_ORIENTATION)

#include "WebDeviceOrientationUpdateProvider.h"

#endif

#if ENABLE(GPU_PROCESS)

#include "RemoteMediaPlayerManager.h"

#if ENABLE(ENCRYPTED_MEDIA)

#include "RemoteCDMFactory.h"

#endif

#if ENABLE(LEGACY_ENCRYPTED_MEDIA)

#include "RemoteLegacyCDMFactory.h"

#endif

#if HAVE(AVASSETREADER)

#include "RemoteImageDecoderAVFManager.h"

#endif

#endif

#if ENABLE(IMAGE_ANALYSIS)

#include <WebCore/TextRecognitionResult.h>

#endif

#if ENABLE(MEDIA_SESSION_COORDINATOR)

#include "RemoteMediaSessionCoordinator.h"

#include <WebCore/MediaSessionCoordinator.h>

#include <WebCore/NavigatorMediaSession.h>

#endif

#if ENABLE(ARKIT_INLINE_PREVIEW_IOS)

#include "ARKitInlinePreviewModelPlayerIOS.h"

#endif

#if PLATFORM(IOS) || PLATFORM(VISION)

#include "WebPreferencesDefaultValuesIOS.h"

#endif

#if ENABLE(MODEL_PROCESS)

#include "ModelProcessConnection.h"

#endif

#if USE(CG)

#include <WebCore/GraphicsContextCG.h>

#endif

#if ENABLE(LOCKDOWN_MODE_API)

#import <pal/spi/cg/CoreGraphicsSPI.h>

#endif

#if ENABLE(WK_WEB_EXTENSIONS)

#include "WebExtensionControllerProxy.h"

#endif

#if ENABLE(WEBXR) && !USE(OPENXR)

#include "PlatformXRSystemProxy.h"

#endif

#if ENABLE(THREADED_ANIMATION_RESOLUTION)

#import <WebCore/AcceleratedTimeline.h>

#endif

#if ENABLE(UNIFIED_TEXT_REPLACEMENT)

#include "UnifiedTextReplacementController.h"

#endif

#if ENABLE(PDF_HUD)

#include "PDFPluginBase.h"

#endif

#if PLATFORM(COCOA)

#include <pal/cf/CoreTextSoftLink.h>

#endif

namespace WebKit {

using namespace JSC;

using namespace WebCore;

static const Seconds pageScrollHysteresisDuration { 300_ms };

static const Seconds initialLayerVolatilityTimerInterval { 20_ms };

static const Seconds maximumLayerVolatilityTimerInterval { 2_s };

#if PLATFORM(IOS_FAMILY)

static constexpr Seconds updateFocusedElementInformationDebounceInterval { 100_ms };

#endif

#define WEBPAGE_RELEASE_LOG(channel, fmt, ...) RELEASE_LOG(channel, "%p - [webPageID=%" PRIu64 "] WebPage::" fmt, this, m_identifier.toUInt64(), ##__VA_ARGS__)

#define WEBPAGE_RELEASE_LOG_ERROR(channel, fmt, ...) RELEASE_LOG_ERROR(channel, "%p - [webPageID=%" PRIu64 "] WebPage::" fmt, this, m_identifier.toUInt64(), ##__VA_ARGS__)

class SendStopResponsivenessTimer {

};

DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, webPageCounter, ("WebPage"));

Ref<WebPage> WebPage::create(PageIdentifier pageID, WebPageCreationParameters&& parameters)

}

static Vector<UserContentURLPattern> parseAndAllowAccessToCORSDisablingPatterns(const Vector<String>& input)

}

static PageConfiguration::ClientCreatorForMainFrame clientCreatorForMainFrame(Ref<WebFrame>&& mainFrame, auto frameType)

}

static RefPtr<Frame> frameFromIdentifier(std::optional<FrameIdentifier> identifier)

}

WebPage::WebPage(PageIdentifier pageID, WebPageCreationParameters&& parameters)

: m_identifier(pageID)

, m_viewSize(parameters.viewSize)

, m_layerHostingMode(parameters.layerHostingMode)

, m_drawingArea(DrawingArea::create(*this, parameters))

, m_mainFrame(WebFrame::create(*this, parameters.subframeProcessPageParameters ? parameters.subframeProcessPageParameters->frameTreeParameters.frameID : (parameters.mainFrameIdentifier ? *parameters.mainFrameIdentifier : WebCore::FrameIdentifier::generate())))

, m_drawingAreaType(parameters.drawingAreaType)

, m_alwaysShowsHorizontalScroller { parameters.alwaysShowsHorizontalScroller }

, m_alwaysShowsVerticalScroller { parameters.alwaysShowsVerticalScroller }

, m_shouldRenderCanvasInGPUProcess { parameters.shouldRenderCanvasInGPUProcess }

, m_shouldRenderDOMInGPUProcess { parameters.shouldRenderDOMInGPUProcess }

, m_shouldPlayMediaInGPUProcess { parameters.shouldPlayMediaInGPUProcess }

#if ENABLE(WEBGL)

, m_shouldRenderWebGLInGPUProcess { parameters.shouldRenderWebGLInGPUProcess}

#endif

#if ENABLE(PLATFORM_DRIVEN_TEXT_CHECKING)

, m_textCheckingControllerProxy(makeUniqueRef<TextCheckingControllerProxy>(*this))

#endif

#if PLATFORM(COCOA) || PLATFORM(GTK)

, m_viewGestureGeometryCollector(makeUnique<ViewGestureGeometryCollector>(*this))

#elif PLATFORM(GTK)

, m_accessibilityObject(nullptr)

#endif

#if USE(GRAPHICS_LAYER_TEXTURE_MAPPER) || USE(GRAPHICS_LAYER_WC)

, m_nativeWindowHandle(parameters.nativeWindowHandle)

#endif

, m_setCanStartMediaTimer(RunLoop::main(), this, &WebPage::setCanStartMediaTimerFired)

#if ENABLE(CONTEXT_MENUS)

, m_contextMenuClient(makeUnique<API::InjectedBundle::PageContextMenuClient>())

#endif

, m_editorClient { makeUnique<API::InjectedBundle::EditorClient>() }

, m_formClient(makeUnique<API::InjectedBundle::FormClient>())

, m_loaderClient(makeUnique<API::InjectedBundle::PageLoaderClient>())

, m_resourceLoadClient(makeUnique<API::InjectedBundle::ResourceLoadClient>())

, m_uiClient(makeUnique<API::InjectedBundle::PageUIClient>())

, m_findController(makeUniqueRef<FindController>(this))

, m_foundTextRangeController(makeUniqueRef<WebFoundTextRangeController>(*this))

, m_inspectorTargetController(makeUnique<WebPageInspectorTargetController>(*this))

, m_userContentController(WebUserContentController::getOrCreate(parameters.userContentControllerParameters.identifier))

, m_screenOrientationManager(makeUniqueRef<WebScreenOrientationManager>(*this))

#if ENABLE(GEOLOCATION)

, m_geolocationPermissionRequestManager(makeUniqueRef<GeolocationPermissionRequestManager>(*this))

#endif

#if ENABLE(MEDIA_STREAM)

, m_userMediaPermissionRequestManager { makeUniqueRef<UserMediaPermissionRequestManager>(*this) }

#endif

#if ENABLE(ENCRYPTED_MEDIA)

, m_mediaKeySystemPermissionRequestManager { makeUniqueRef<MediaKeySystemPermissionRequestManager>(*this) }

#endif

, m_pageScrolledHysteresis([this](PAL::HysteresisState state) { if (state == PAL::HysteresisState::Stopped) pageStoppedScrolling(); }, pageScrollHysteresisDuration)

, m_canRunBeforeUnloadConfirmPanel(parameters.canRunBeforeUnloadConfirmPanel)

, m_canRunModal(parameters.canRunModal)

#if HAVE(TOUCH_BAR)

, m_requiresUserActionForEditingControlsManager(parameters.requiresUserActionForEditingControlsManager)

#endif

#if HAVE(UIKIT_RESIZABLE_WINDOWS)

, m_isWindowResizingEnabled(parameters.hasResizableWindows)

#endif

#if ENABLE(META_VIEWPORT)

, m_forceAlwaysUserScalable(parameters.ignoresViewportScaleLimits)

#endif

#if PLATFORM(IOS_FAMILY)

, m_screenIsBeingCaptured(parameters.isCapturingScreen)

, m_screenSize(parameters.screenSize)

, m_availableScreenSize(parameters.availableScreenSize)

, m_overrideScreenSize(parameters.overrideScreenSize)

, m_overrideAvailableScreenSize(parameters.overrideAvailableScreenSize)

, m_deviceOrientation(parameters.deviceOrientation)

, m_keyboardIsAttached(parameters.hardwareKeyboardState.isAttached)

, m_canShowWhileLocked(parameters.canShowWhileLocked)

, m_updateFocusedElementInformationTimer(*this, &WebPage::updateFocusedElementInformation, updateFocusedElementInformationDebounceInterval)

#endif

, m_layerVolatilityTimer(*this, &WebPage::layerVolatilityTimerFired)

, m_activityState(parameters.activityState)

, m_userActivity("App nap disabled for page due to user activity"_s)

, m_userInterfaceLayoutDirection(parameters.userInterfaceLayoutDirection)

, m_overrideContentSecurityPolicy { parameters.overrideContentSecurityPolicy }

, m_cpuLimit(parameters.cpuLimit)

#if USE(WPE_RENDERER)

, m_hostFileDescriptor(WTFMove(parameters.hostFileDescriptor))

#endif

, m_webPageProxyIdentifier(parameters.webPageProxyIdentifier)

#if ENABLE(TEXT_AUTOSIZING)

, m_textAutoSizingAdjustmentTimer(*this, &WebPage::textAutoSizingAdjustmentTimerFired)

#endif

, m_overriddenMediaType(parameters.overriddenMediaType)

, m_processDisplayName(parameters.processDisplayName)

#if (PLATFORM(GTK) || PLATFORM(WPE)) && USE(GBM)

, m_preferredBufferFormats(WTFMove(parameters.preferredBufferFormats))

#endif

#if ENABLE(APP_BOUND_DOMAINS)

, m_limitsNavigationsToAppBoundDomains(parameters.limitsNavigationsToAppBoundDomains)

#endif

, m_lastNavigationWasAppInitiated(parameters.lastNavigationWasAppInitiated)

#if ENABLE(APP_HIGHLIGHTS)

, m_appHighlightsVisible(parameters.appHighlightsVisible)

#endif

, m_historyItemClient(WebHistoryItemClient::create())

#if ENABLE(UNIFIED_TEXT_REPLACEMENT)

, m_unifiedTextReplacementController(makeUniqueRef<UnifiedTextReplacementController>(*this))

#endif

{

ASSERT(m_identifier);

WEBPAGE_RELEASE_LOG(Loading, "constructor:");

#if PLATFORM(IOS) || PLATFORM(VISION)

setAllowsDeprecatedSynchronousXMLHttpRequestDuringUnload(parameters.allowsDeprecatedSynchronousXMLHttpRequestDuringUnload);

#endif

#if PLATFORM(COCOA)

auto shouldBlockIOKit = parameters.store.getBoolValueForKey(WebPreferencesKey::blockIOKitInWebContentSandboxKey())

#if ENABLE(WEBGL)

&& m_shouldRenderWebGLInGPUProcess

&& m_drawingAreaType == DrawingAreaType::RemoteLayerTree

#endif

&& m_shouldRenderCanvasInGPUProcess

&& m_shouldRenderDOMInGPUProcess

&& m_shouldPlayMediaInGPUProcess;

if (shouldBlockIOKit) {

#if HAVE(SANDBOX_STATE_FLAGS) && !ENABLE(WEBCONTENT_GPU_SANDBOX_EXTENSIONS_BLOCKING)

auto auditToken = WebProcess::singleton().auditTokenForSelf();

sandbox_enable_state_flag("BlockIOKitInWebContentSandbox", *auditToken);

#endif

ProcessCapabilities::setHardwareAcceleratedDecodingDisabled(true);

ProcessCapabilities::setCanUseAcceleratedBuffers(false);

#if HAVE(CGIMAGESOURCE_DISABLE_HARDWARE_DECODING)

static bool disabled { false };

if (!std::exchange(disabled, true)) {

OSStatus ok = CGImageSourceDisableHardwareDecoding();

ASSERT_UNUSED(ok, ok == noErr);

}

#endif

}

#endif

m_pageGroup = WebProcess::singleton().webPageGroup(parameters.pageGroupData);

auto frameType = parameters.subframeProcessPageParameters ? Frame::FrameType::Remote : Frame::FrameType::Local;

PageConfiguration pageConfiguration(

pageID,

WebProcess::singleton().sessionID(),

makeUniqueRef<WebEditorClient>(this),

WebSocketProvider::create(parameters.webPageProxyIdentifier),

createLibWebRTCProvider(*this),

WebProcess::singleton().cacheStorageProvider(),

m_userContentController,

WebBackForwardListProxy::create(*this),

WebProcess::singleton().cookieJar(),

makeUniqueRef<WebProgressTrackerClient>(*this),

clientCreatorForMainFrame(m_mainFrame.copyRef(), frameType),

m_mainFrame->frameID(),

frameFromIdentifier(parameters.openerFrameIdentifier),

makeUniqueRef<WebSpeechRecognitionProvider>(pageID),

makeUniqueRef<MediaRecorderProvider>(*this),

WebProcess::singleton().broadcastChannelRegistry(),

makeUniqueRef<WebStorageProvider>(WebProcess::singleton().mediaKeysStorageDirectory(), WebProcess::singleton().mediaKeysStorageSalt()),

makeUniqueRef<WebModelPlayerProvider>(*this),

WebProcess::singleton().badgeClient(),

m_historyItemClient.copyRef(),

#if ENABLE(CONTEXT_MENUS)

makeUniqueRef<WebContextMenuClient>(this),

#endif

#if ENABLE(APPLE_PAY)

makeUniqueRef<WebPaymentCoordinator>(*this),

#endif

makeUniqueRef<WebChromeClient>(*this),

makeUniqueRef<WebCryptoClient>(this->identifier())

);

#if ENABLE(DRAG_SUPPORT)

pageConfiguration.dragClient = makeUnique<WebDragClient>(this);

#endif

pageConfiguration.inspectorClient = makeUnique<WebInspectorClient>(this);

#if USE(AUTOCORRECTION_PANEL)

pageConfiguration.alternativeTextClient = makeUnique<WebAlternativeTextClient>(this);

#endif

pageConfiguration.diagnosticLoggingClient = makeUnique<WebDiagnosticLoggingClient>(*this);

pageConfiguration.performanceLoggingClient = makeUnique<WebPerformanceLoggingClient>(*this);

pageConfiguration.screenOrientationManager = m_screenOrientationManager.get();

#if ENABLE(SPEECH_SYNTHESIS) && !USE(GSTREAMER)

pageConfiguration.speechSynthesisClient = makeUnique<WebSpeechSynthesisClient>(*this);

#endif

#if PLATFORM(COCOA) || PLATFORM(GTK)

pageConfiguration.validationMessageClient = makeUnique<WebValidationMessageClient>(*this);

#endif

pageConfiguration.databaseProvider = WebDatabaseProvider::getOrCreate(m_pageGroup->pageGroupID());

pageConfiguration.pluginInfoProvider = &WebPluginInfoProvider::singleton();

pageConfiguration.storageNamespaceProvider = WebStorageNamespaceProvider::getOrCreate();

pageConfiguration.visitedLinkStore = VisitedLinkTableController::getOrCreate(parameters.visitedLinkTableID);

#if ENABLE(WEB_AUTHN)

pageConfiguration.authenticatorCoordinatorClient = makeUnique<WebAuthenticatorCoordinator>(*this);

#endif

#if ENABLE(APPLICATION_MANIFEST)

pageConfiguration.applicationManifest = parameters.applicationManifest;

#endif

#if PLATFORM(IOS_FAMILY) && ENABLE(DEVICE_ORIENTATION)

pageConfiguration.deviceOrientationUpdateProvider = WebDeviceOrientationUpdateProvider::create(*this);

#endif

#if ENABLE(WK_WEB_EXTENSIONS)

if (parameters.webExtensionControllerParameters)

m_webExtensionController = WebExtensionControllerProxy::getOrCreate(parameters.webExtensionControllerParameters.value(), this);

#endif

m_corsDisablingPatterns = WTFMove(parameters.corsDisablingPatterns);

if (!m_corsDisablingPatterns.isEmpty())

synchronizeCORSDisablingPatternsWithNetworkProcess();

pageConfiguration.corsDisablingPatterns = parseAndAllowAccessToCORSDisablingPatterns(m_corsDisablingPatterns);

pageConfiguration.maskedURLSchemes = parameters.maskedURLSchemes;

pageConfiguration.userScriptsShouldWaitUntilNotification = parameters.userScriptsShouldWaitUntilNotification;

pageConfiguration.loadsSubresources = parameters.loadsSubresources;

pageConfiguration.allowedNetworkHosts = parameters.allowedNetworkHosts;

pageConfiguration.shouldRelaxThirdPartyCookieBlocking = parameters.shouldRelaxThirdPartyCookieBlocking;

pageConfiguration.httpsUpgradeEnabled = parameters.httpsUpgradeEnabled;

pageConfiguration.portsForUpgradingInsecureSchemeForTesting = parameters.portsForUpgradingInsecureSchemeForTesting;

if (!parameters.crossOriginAccessControlCheckEnabled)

CrossOriginAccessControlCheckDisabler::singleton().setCrossOriginAccessControlCheckEnabled(false);

#if ENABLE(ATTACHMENT_ELEMENT)

pageConfiguration.attachmentElementClient = makeUnique<WebAttachmentElementClient>(*this);

#endif

pageConfiguration.contentSecurityPolicyModeForExtension = parameters.contentSecurityPolicyModeForExtension;

#if PLATFORM(COCOA)

static bool hasConsumedGPUExtensionHandles = false;

if (!hasConsumedGPUExtensionHandles) {

SandboxExtension::consumePermanently(parameters.gpuIOKitExtensionHandles);

SandboxExtension::consumePermanently(parameters.gpuMachExtensionHandles);

hasConsumedGPUExtensionHandles = true;

}

#endif

#if HAVE(STATIC_FONT_REGISTRY)

if (parameters.fontMachExtensionHandles.size())

WebProcess::singleton().switchFromStaticFontRegistryToUserFontRegistry(WTFMove(parameters.fontMachExtensionHandles));

#endif

bool receivedMainFrameIdentifierFromUIProcess = !!parameters.subframeProcessPageParameters;

m_page = Page::create(WTFMove(pageConfiguration));

updateAfterDrawingAreaCreation(parameters);

if (parameters.displayID)

windowScreenDidChange(*parameters.displayID, parameters.nominalFramesPerSecond);

WebStorageNamespaceProvider::incrementUseCount(sessionStorageNamespaceIdentifier());

updatePreferences(parameters.store);

#if PLATFORM(IOS_FAMILY) || ENABLE(ROUTING_ARBITRATION)

DeprecatedGlobalSettings::setShouldManageAudioSessionCategory(true);

#endif

m_backgroundColor = parameters.backgroundColor;

// We need to set the device scale factor before creating the drawing area

// to ensure it's created with the right size.

m_page->setDeviceScaleFactor(parameters.deviceScaleFactor);

#if USE(COORDINATED_GRAPHICS) || USE(TEXTURE_MAPPER)

if (m_drawingArea->enterAcceleratedCompositingModeIfNeeded() && !parameters.isProcessSwap)

m_drawingArea->sendEnterAcceleratedCompositingModeIfNeeded();

#endif

// FIXME: Refactor frame construction and remove receivedMainFrameIdentifierFromUIProcess. <rdar://116201135>

m_drawingArea->setShouldScaleViewToFitDocument(parameters.shouldScaleViewToFitDocument);

if (parameters.isProcessSwap)

freezeLayerTree(LayerTreeFreezeReason::ProcessSwap);

#if ENABLE(ASYNC_SCROLLING)

m_useAsyncScrolling = parameters.store.getBoolValueForKey(WebPreferencesKey::threadedScrollingEnabledKey());

if (!m_drawingArea->supportsAsyncScrolling())

m_useAsyncScrolling = false;

m_page->settings().setScrollingCoordinatorEnabled(m_useAsyncScrolling);

#endif

// Disable Back/Forward cache expiration in the WebContent process since management happens in the UIProcess

// in modern WebKit.

m_page->settings().setBackForwardCacheExpirationInterval(Seconds::infinity());

m_mainFrame->initWithCoreMainFrame(*this, m_page->mainFrame(), receivedMainFrameIdentifierFromUIProcess);

if (auto& subframeProcessPageParameters = parameters.subframeProcessPageParameters) {

for (auto& childParameters : subframeProcessPageParameters->frameTreeParameters.children)

constructFrameTree(m_mainFrame.get(), childParameters);

m_page->setMainFrameURL(subframeProcessPageParameters->initialMainDocumentURL);

if (auto websitePolicies = subframeProcessPageParameters->websitePoliciesData) {

if (auto* remoteMainFrameClient = m_mainFrame->remoteFrameClient())

remoteMainFrameClient->applyWebsitePolicies(WTFMove(*subframeProcessPageParameters->websitePoliciesData));

}

}

m_drawingArea->updatePreferences(parameters.store);

setBackgroundExtendsBeyondPage(parameters.backgroundExtendsBeyondPage);

setPageAndTextZoomFactors(parameters.pageZoomFactor, parameters.textZoomFactor);

// FIXME: These should use makeUnique and makeUniqueRef instead of new.

#if ENABLE(GEOLOCATION)

WebCore::provideGeolocationTo(m_page.get(), *new WebGeolocationClient(*this));

#endif

#if ENABLE(NOTIFICATIONS)

WebCore::provideNotification(m_page.get(), new WebNotificationClient(this));

#endif

#if ENABLE(MEDIA_STREAM)

WebCore::provideUserMediaTo(m_page.get(), new WebUserMediaClient(*this));

#endif

#if ENABLE(ENCRYPTED_MEDIA)

WebCore::provideMediaKeySystemTo(*m_page.get(), *new WebMediaKeySystemClient(*this));

#endif

m_page->setControlledByAutomation(parameters.controlledByAutomation);

m_page->setHasResourceLoadClient(parameters.hasResourceLoadClient);

m_page->setCanStartMedia(false);

m_mayStartMediaWhenInWindow = parameters.mayStartMediaWhenInWindow;

if (parameters.mediaPlaybackIsSuspended)

m_page->suspendAllMediaPlayback();

if (parameters.openedByDOM)

m_page->setOpenedByDOM();

m_page->setGroupName(m_pageGroup->identifier());

m_page->setUserInterfaceLayoutDirection(m_userInterfaceLayoutDirection);

#if PLATFORM(IOS_FAMILY)

m_page->setTextAutosizingWidth(parameters.textAutosizingWidth);

setOverrideViewportArguments(parameters.overrideViewportArguments);

#endif

platformInitialize(parameters);

setUseFixedLayout(parameters.useFixedLayout);

setDefaultUnobscuredSize(parameters.defaultUnobscuredSize);

setMinimumUnobscuredSize(parameters.minimumUnobscuredSize);

setMaximumUnobscuredSize(parameters.maximumUnobscuredSize);

setUnderlayColor(parameters.underlayColor);

setPaginationMode(parameters.paginationMode);

setPaginationBehavesLikeColumns(parameters.paginationBehavesLikeColumns);

setPageLength(parameters.pageLength);

setGapBetweenPages(parameters.gapBetweenPages);

effectiveAppearanceDidChange(parameters.useDarkAppearance, parameters.useElevatedUserInterfaceLevel);

if (parameters.isEditable)

setEditable(true);

#if PLATFORM(MAC)

setUseSystemAppearance(parameters.useSystemAppearance);

setUseFormSemanticContext(parameters.useFormSemanticContext);

setHeaderBannerHeight(parameters.headerBannerHeight);

setFooterBannerHeight(parameters.footerBannerHeight);

if (parameters.viewWindowCoordinates)

windowAndViewFramesChanged(*parameters.viewWindowCoordinates);

#endif

// If the page is created off-screen, its visibilityState should be prerender.

m_page->setActivityState(m_activityState);

if (!isVisible())

m_page->setIsPrerender();

updateIsInWindow(true);

setMinimumSizeForAutoLayout(parameters.minimumSizeForAutoLayout);

setSizeToContentAutoSizeMaximumSize(parameters.sizeToContentAutoSizeMaximumSize);

setAutoSizingShouldExpandToViewHeight(parameters.autoSizingShouldExpandToViewHeight);

setViewportSizeForCSSViewportUnits(parameters.viewportSizeForCSSViewportUnits);

setScrollPinningBehavior(parameters.scrollPinningBehavior);

if (parameters.scrollbarOverlayStyle)

m_scrollbarOverlayStyle = static_cast<ScrollbarOverlayStyle>(parameters.scrollbarOverlayStyle.value());

else

m_scrollbarOverlayStyle = std::optional<ScrollbarOverlayStyle>();

setTopContentInset(parameters.topContentInset);

m_userAgent = parameters.userAgent;

// Do not overwrite existing items. Due to process swapping and back/forward cache support, there may be other

// (suspended) WebPages in this process for the same WebPageProxy in the UIProcess. Overwriting the HistoryItems

// would break back/forward cache for those other pages since the HistoryItems hold the CachedPage.

if (!parameters.itemStates.isEmpty())

restoreSessionInternal(parameters.itemStates, parameters.itemStatesWereRestoredByAPIRequest ? WasRestoredByAPIRequest::Yes : WasRestoredByAPIRequest::No, WebBackForwardListProxy::OverwriteExistingItem::No);

setMediaVolume(parameters.mediaVolume);

setMuted(parameters.muted, [] { });

// We use the DidFirstVisuallyNonEmptyLayout milestone to determine when to unfreeze the layer tree.

m_page->addLayoutMilestones({ WebCore::LayoutMilestone::DidFirstLayout, WebCore::LayoutMilestone::DidFirstVisuallyNonEmptyLayout });

auto& webProcess = WebProcess::singleton();

webProcess.addMessageReceiver(Messages::WebPage::messageReceiverName(), m_identifier, *this);

// FIXME: This should be done in the object constructors, and the objects themselves should be message receivers.

webProcess.addMessageReceiver(Messages::WebInspector::messageReceiverName(), m_identifier, *this);

webProcess.addMessageReceiver(Messages::WebInspectorUI::messageReceiverName(), m_identifier, *this);

webProcess.addMessageReceiver(Messages::RemoteWebInspectorUI::messageReceiverName(), m_identifier, *this);

#if ENABLE(FULLSCREEN_API)

webProcess.addMessageReceiver(Messages::WebFullScreenManager::messageReceiverName(), m_identifier, *this);

#endif

#ifndef NDEBUG

webPageCounter.increment();

#endif

#if ENABLE(SCROLLING_THREAD)

if (m_useAsyncScrolling)

m_drawingArea->registerScrollingTree();

#endif

for (auto& mimeType : parameters.mimeTypesWithCustomContentProviders)

m_mimeTypesWithCustomContentProviders.add(mimeType);

if (parameters.viewScaleFactor != 1)

scaleView(parameters.viewScaleFactor);

m_page->addLayoutMilestones(parameters.observedLayoutMilestones);

#if PLATFORM(COCOA)

setSmartInsertDeleteEnabled(parameters.smartInsertDeleteEnabled);

#endif

#if HAVE(APP_ACCENT_COLORS)

setAccentColor(parameters.accentColor);

#if PLATFORM(MAC)

setAppUsesCustomAccentColor(parameters.appUsesCustomAccentColor);

#endif

#endif

m_needsFontAttributes = parameters.needsFontAttributes;

#if ENABLE(WEB_RTC)

if (!parameters.iceCandidateFilteringEnabled)

m_page->disableICECandidateFiltering();

#if USE(LIBWEBRTC)

if (parameters.enumeratingAllNetworkInterfacesEnabled) {

auto& rtcProvider = static_cast<LibWebRTCProvider&>(m_page->webRTCProvider());

rtcProvider.enableEnumeratingAllNetworkInterfaces();

}

if (parameters.store.getBoolValueForKey(WebPreferencesKey::enumeratingVisibleNetworkInterfacesEnabledKey())) {

auto& rtcProvider = static_cast<LibWebRTCProvider&>(m_page->webRTCProvider());

rtcProvider.enableEnumeratingVisibleNetworkInterfaces();

}

#endif

#endif

for (const auto& iterator : parameters.urlSchemeHandlers)

registerURLSchemeHandler(iterator.value, iterator.key);

for (auto& scheme : parameters.urlSchemesWithLegacyCustomProtocolHandlers)

LegacySchemeRegistry::registerURLSchemeAsHandledBySchemeHandler({ scheme });