/*

* Copyright (C) 2010-2025 Apple Inc. All rights reserved.

* Copyright (C) 2012 Intel Corporation. All rights reserved.

* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

*

* 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 "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 "DragEventForwardingData.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 "ImageOptions.h"

#include "InjectUserScriptImmediately.h"

#include "InjectedBundle.h"

#include "InjectedBundleHitTestResult.h"

#include "InjectedBundleScriptWorld.h"

#include "JavaScriptEvaluationResult.h"

#include "LibWebRTCCodecs.h"

#include "LibWebRTCProvider.h"

#include "LoadParameters.h"

#include "Logging.h"

#include "MediaKeySystemPermissionRequestManager.h"

#include "MediaPlaybackState.h"

#include "MessageSenderInlines.h"

#include "NetworkConnectionToWebProcessMessages.h"

#include "NetworkProcessConnection.h"

#include "NodeHitTestResult.h"

#include "NotificationPermissionRequestManager.h"

#include "PageBanner.h"

#include "PageInspectorTarget.h"

#include "PluginView.h"

#include "PolicyDecision.h"

#include "PrintInfo.h"

#include "ProvisionalFrameCreationParameters.h"

#include "RemoteRenderingBackendProxy.h"

#include "RemoteScrollingCoordinator.h"

#include "RemoteSnapshotRecorderProxy.h"

#include "RemoteWebInspectorUI.h"

#include "RemoteWebInspectorUIMessages.h"

#include "RunJavaScriptParameters.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 "WebCryptoClient.h"

#include "WebDataListSuggestionPicker.h"

#include "WebDatabaseProvider.h"

#include "WebDateTimeChooser.h"

#include "WebDiagnosticLoggingClient.h"

#include "WebDocumentSyncClient.h"

#include "WebDragClient.h"

#include "WebEditorClient.h"

#include "WebErrors.h"

#include "WebEventConversion.h"

#include "WebEventFactory.h"

#include "WebFoundTextRange.h"

#include "WebFoundTextRangeController.h"

#include "WebFrame.h"

#include "WebFrameMetrics.h"

#include "WebFullScreenManager.h"

#include "WebFullScreenManagerMessages.h"

#include "WebFullScreenManagerProxyMessages.h"

#include "WebGamepadProvider.h"

#include "WebGeolocationClient.h"

#include "WebHistoryItemClient.h"

#include "WebHitTestResultData.h"

#include "WebImage.h"

#include "WebInspectorBackend.h"

#include "WebInspectorBackendClient.h"

#include "WebInspectorBackendMessages.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 "WebPageInternals.h"

#include "WebPageMessages.h"

#include "WebPageOverlay.h"

#include "WebPageProxyMessages.h"

#include "WebPageTesting.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/AXObjectCache.h>

#include <WebCore/AnimationTimelinesController.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/ContainerNodeInlines.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/DisplayListRecorderImpl.h>

#include <WebCore/Document.h>

#include <WebCore/DocumentFragment.h>

#include <WebCore/DocumentFullscreen.h>

#include <WebCore/DocumentImmersive.h>

#include <WebCore/DocumentInlines.h>

#include <WebCore/DocumentLoader.h>

#include <WebCore/DocumentMarkerController.h>

#include <WebCore/DocumentMarkers.h>

#include <WebCore/DocumentPage.h>

#include <WebCore/DocumentQuirks.h>

#include <WebCore/DocumentStorageAccess.h>

#include <WebCore/DocumentView.h>

#include <WebCore/DragController.h>

#include <WebCore/DragData.h>

#include <WebCore/DragEventTargetData.h>

#include <WebCore/Editing.h>

#include <WebCore/Editor.h>

#include <WebCore/ElementAncestorIteratorInlines.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/FocusControllerTypes.h>

#include <WebCore/FocusOptions.h>

#include <WebCore/FontAttributeChanges.h>

#include <WebCore/FontAttributes.h>

#include <WebCore/FormState.h>

#include <WebCore/FragmentDirectiveParser.h>

#include <WebCore/FragmentDirectiveRangeFinder.h>

#include <WebCore/FragmentDirectiveUtilities.h>

#include <WebCore/FrameDestructionObserverInlines.h>

#include <WebCore/FrameInlines.h>

#include <WebCore/FrameInspectorController.h>

#include <WebCore/FrameLoadRequest.h>

#include <WebCore/FrameLoaderTypes.h>

#include <WebCore/GeometryUtilities.h>

#include <WebCore/HTMLAttachmentElement.h>

#include <WebCore/HTMLBodyElement.h>

#include <WebCore/HTMLFormElement.h>

#include <WebCore/HTMLImageElement.h>

#include <WebCore/HTMLInputElement.h>

#include <WebCore/HTMLModelElement.h>

#include <WebCore/HTMLPlugInElement.h>

#include <WebCore/HTMLSelectElement.h>

#include <WebCore/HTMLTextAreaElement.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/JSDOMExceptionHandling.h>

#include <WebCore/JSNode.h>

#include <WebCore/KeyboardEvent.h>

#include <WebCore/LegacySchemeRegistry.h>

#include <WebCore/LocalFrameInlines.h>

#include <WebCore/LocalFrameView.h>

#include <WebCore/LocalizedStrings.h>

#include <WebCore/LoginStatus.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/MediaDocument.h>

#include <WebCore/MediaPlayer.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/PageInspectorController.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/PopupMenuClient.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/RemoteFrameGeometryTransformer.h>

#include <WebCore/RemoteFrameView.h>

#include <WebCore/RemoteUserInputEventData.h>

#include <WebCore/RenderImage.h>

#include <WebCore/RenderLayer.h>

#include <WebCore/RenderLayerCompositor.h>

#include <WebCore/RenderTheme.h>

#include <WebCore/RenderTreeAsText.h>

#include <WebCore/RenderVideoInlines.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/SystemPreviewInfo.h>

#include <WebCore/TextExtraction.h>

#include <WebCore/TextIterator.h>

#include <WebCore/TextManipulationController.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/WebKitJSHandle.h>

#include <WebCore/WritingDirection.h>

#include <WebCore/markup.h>

#include <algorithm>

#include <pal/SessionID.h>

#include <ranges>

#include <wtf/CoroutineUtilities.h>

#include <wtf/ProcessID.h>

#include <wtf/RunLoop.h>

#include <wtf/Scope.h>

#include <wtf/SetForScope.h>

#include <wtf/SystemTracing.h>

#include <wtf/text/MakeString.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 "RemoteObjectRegistryMessages.h"

#include "TextAnimationController.h"

#include "TextCheckingControllerProxy.h"

#include "VideoPresentationManager.h"

#include "WKStringCF.h"

#include "WebRemoteObjectRegistry.h"

#include <WebCore/ImageUtilities.h>

#include <WebCore/LegacyWebArchive.h>

#include <WebCore/VP9UtilitiesCocoa.h>

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

#include <wtf/MachSendRight.h>

#include <wtf/cocoa/RuntimeApplicationChecksCocoa.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

#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 "DigitalCredentialsCoordinator.h"

#include "WebAuthenticatorCoordinator.h"

#include <WebCore/AuthenticatorCoordinator.h>

#include <WebCore/DigitalCredentialsRequestData.h>

#include <WebCore/DigitalCredentialsResponseData.h>

#include <WebCore/ExceptionData.h>

#endif // ENABLE(WEB_AUTHN)

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

#include <WebCore/FontRenderOptions.h>

#endif

#if USE(CG)

// FIXME: Move the CG-specific PDF painting code out of WebPage.cpp.

#include <WebCore/GraphicsContextCG.h>

#endif

#if ENABLE(LOCKDOWN_MODE_API)

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

#endif

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

#include "WebExtensionControllerProxy.h"

#endif

#if ENABLE(WEBXR)

#include "PlatformXRSystemProxy.h"

#endif

#if ENABLE(PDF_HUD)

#include "PDFPluginBase.h"

#endif

#if HAVE(AUDIT_TOKEN)

#include "CoreIPCAuditToken.h"

#endif

#if ENABLE(VIDEO) || ENABLE(WEB_AUDIO)

#include "RemoteMediaSessionManager.h"

#endif

#if __has_include(<WebKitAdditions/WebPreferencesDefaultValuesAdditions.h>)

#include <WebKitAdditions/WebPreferencesDefaultValuesAdditions.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 };

static constexpr Seconds updateLayoutViewportHeightExpansionTimerInterval { 200_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_FORWARDABLE(channel, fmt, ...) RELEASE_LOG_FORWARDABLE(channel, fmt, 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 {

public:

~SendStopResponsivenessTimer()

{

protect(WebProcess::singleton().parentProcessConnection())->send(Messages::WebProcessProxy::StopResponsivenessTimer(), 0);

}

};

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

{

String openedMainFrameName = parameters.openedMainFrameName;

auto page = adoptRef(*new WebPage(pageID, WTF::move(parameters)));

if (RefPtr injectedBundle = WebProcess::singleton().injectedBundle())

injectedBundle->didCreatePage(page);

page->corePage()->mainFrame().tree().setSpecifiedName(AtomString(openedMainFrameName));

#if HAVE(SANDBOX_STATE_FLAGS)

setHasLaunchedWebContentProcess();

#endif

return page;

}

void WebPage::ref() const

{

API::ObjectImpl<API::Object::Type::BundlePage>::ref();

}

void WebPage::deref() const

{

API::ObjectImpl<API::Object::Type::BundlePage>::deref();

}

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

{

return WTF::compactMap(input, [](auto& pattern) -> std::optional<UserContentURLPattern> {

UserContentURLPattern parsedPattern(pattern);

if (!parsedPattern.isValid())

return std::nullopt;

WebCore::OriginAccessPatternsForWebProcess::singleton().allowAccessTo(parsedPattern);

return parsedPattern;

});

}

static PageConfiguration::MainFrameCreationParameters mainFrameCreationParameters(Ref<WebFrame>&& mainFrame, auto frameType, auto initialSandboxFlags, auto initialReferrerPolicy)

{

auto invalidator = mainFrame->makeInvalidator();

switch (frameType) {

case Frame::FrameType::Local:

return PageConfiguration::LocalMainFrameCreationParameters {

{ [mainFrame = WTF::move(mainFrame), invalidator = WTF::move(invalidator)] (auto& localFrame, auto& frameLoader) mutable {

return makeUniqueRefWithoutRefCountedCheck<WebLocalFrameLoaderClient>(localFrame, frameLoader, WTF::move(mainFrame), WTF::move(invalidator));

} },

initialSandboxFlags,

initialReferrerPolicy

};

case Frame::FrameType::Remote:

return CompletionHandler<UniqueRef<RemoteFrameClient>(RemoteFrame&)> { [mainFrame = WTF::move(mainFrame), invalidator = WTF::move(invalidator)] (auto&) mutable {

return makeUniqueRef<WebRemoteFrameClient>(WTF::move(mainFrame), WTF::move(invalidator));

} };

}

RELEASE_ASSERT_NOT_REACHED();

}

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

{

if (!identifier)

return nullptr;

RefPtr webFrame = WebProcess::singleton().webFrame(*identifier);

if (!webFrame)

return nullptr;

return webFrame->coreFrame();

}

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

: m_internals(makeUniqueRef<Internals>())

, m_identifier(pageID)

, m_viewSize(parameters.viewSize)

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

, m_webPageTesting(WebPageTesting::create(*this))

, m_mainFrame(WebFrame::create(*this, parameters.mainFrameIdentifier))

#if ENABLE(TILED_CA_DRAWING_AREA)

, m_drawingAreaType(parameters.drawingAreaType)

#endif

, 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

, m_shouldSendConsoleLogsToUIProcessForTesting(parameters.shouldSendConsoleLogsToUIProcessForTesting)

#if HAVE(NSVIEW_CORNER_CONFIGURATION)

, m_scrollbarAvoidanceCornerRadii(parameters.scrollbarAvoidanceCornerRadii)

#endif

#if ENABLE(PLATFORM_DRIVEN_TEXT_CHECKING)

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

#endif

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

, m_viewGestureGeometryCollector(ViewGestureGeometryCollector::create(*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::mainSingleton(), "WebPage::SetCanStartMediaTimer"_s, 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_userContentController(WebUserContentController::getOrCreate(WTF::move(parameters.userContentControllerParameters)))

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

#if ENABLE(GEOLOCATION)

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

#endif

#if ENABLE(MEDIA_STREAM)

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

#endif

#if ENABLE(ENCRYPTED_MEDIA)

, m_mediaKeySystemPermissionRequestManager { makeUniqueRefWithoutRefCountedCheck<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 PLATFORM(MAC)

, m_overflowHeightForTopScrollEdgeEffect(parameters.overflowHeightForTopScrollEdgeEffect)

#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_updateFocusedElementInformationTimer(*this, &WebPage::updateFocusedElementInformation, updateFocusedElementInformationDebounceInterval)

#endif

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

, m_activityState(parameters.activityState)

, m_userInterfaceLayoutDirection(parameters.userInterfaceLayoutDirection)

, m_overrideContentSecurityPolicy { WTF::move(parameters.overrideContentSecurityPolicy) }

, m_cpuLimit(parameters.cpuLimit)

#if USE(WPE_RENDERER)

, m_hostFileDescriptor(WTF::move(parameters.hostFileDescriptor))

#endif

, m_webPageProxyIdentifier(parameters.webPageProxyIdentifier)

#if ENABLE(TEXT_AUTOSIZING)

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

#endif

, m_overriddenMediaType { WTF::move(parameters.overriddenMediaType) }

, m_processDisplayName { WTF::move(parameters.processDisplayName) }

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

#if USE(GBM) || OS(ANDROID)

, m_preferredBufferFormats(WTF::move(parameters.preferredBufferFormats))

#endif

#endif

#if ENABLE(APP_BOUND_DOMAINS)

, m_limitsNavigationsToAppBoundDomains(parameters.limitsNavigationsToAppBoundDomains)

#endif

, m_lastNavigationWasAppInitiated(parameters.lastNavigationWasAppInitiated)

#if PLATFORM(IOS_FAMILY)

, m_updateLayoutViewportHeightExpansionTimer(*this, &WebPage::updateLayoutViewportHeightExpansionTimerFired, updateLayoutViewportHeightExpansionTimerInterval)

#endif

#if ENABLE(IPC_TESTING_API)

, m_visitedLinkTableID(parameters.visitedLinkTableID)

#endif

#if ENABLE(APP_HIGHLIGHTS)

, m_appHighlightsVisible(parameters.appHighlightsVisible)

#endif

, m_historyItemClient(WebHistoryItemClient::create(*this))

#if ENABLE(WRITING_TOOLS)

, m_textAnimationController(makeUniqueRef<TextAnimationController>(*this))

#endif

, m_backgroundTextExtractionEnabled(parameters.backgroundTextExtractionEnabled)

, m_isPopup(parameters.isPopup)

#if ENABLE(MODEL_ELEMENT_IMMERSIVE)

, m_allowsImmersiveEnvironments(parameters.allowsImmersiveEnvironments)

#endif

{

WEBPAGE_RELEASE_LOG(Loading, "constructor:");

#if PLATFORM(COCOA)

#if HAVE(SANDBOX_STATE_FLAGS)

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

auto shouldBlockWebInspector = parameters.store.getBoolValueForKey(WebPreferencesKey::blockWebInspectorInWebContentSandboxKey());

if (shouldBlockWebInspector)

sandbox_enable_state_flag("BlockWebInspectorInWebContentSandbox", *auditToken);

#if PLATFORM(IOS)

auto shouldBlockMobileGestalt = parameters.store.getBoolValueForKey(WebPreferencesKey::blockMobileGestaltInWebContentSandboxKey());

if (shouldBlockMobileGestalt)

sandbox_enable_state_flag("BlockMobileGestaltInWebContentSandbox", *auditToken);

#endif

auto shouldBlockMobileAsset = parameters.store.getBoolValueForKey(WebPreferencesKey::blockMobileAssetInWebContentSandboxKey());

if (shouldBlockMobileAsset)

sandbox_enable_state_flag("BlockMobileAssetInWebContentSandbox", *auditToken);

auto unifiedPDFEnabled = parameters.store.getBoolValueForKey(WebPreferencesKey::unifiedPDFEnabledKey());

if (unifiedPDFEnabled)

sandbox_enable_state_flag("UnifiedPDFEnabled", *auditToken);

#if PLATFORM(MAC)

auto shouldAllowInstalledFonts = parameters.store.getBoolValueForKey(WebPreferencesKey::shouldAllowUserInstalledFontsKey());

if (!shouldAllowInstalledFonts || !WTF::MacApplication::isAppleMail())

sandbox_enable_state_flag("BlockUserInstalledFonts", *auditToken);

auto shouldBlockFontService = parameters.store.getBoolValueForKey(WebPreferencesKey::blockFontServiceInWebContentSandboxKey());

if (shouldBlockFontService)

sandbox_enable_state_flag("BlockFontServiceInWebContentSandbox", *auditToken);

auto shouldBlockIconServices = parameters.store.getBoolValueForKey(WebPreferencesKey::blockIconServicesInWebContentSandboxKey());

if (shouldBlockIconServices)

sandbox_enable_state_flag("BlockIconServicesInWebContentSandbox", *auditToken);

auto shouldBlockOpenDirectory = parameters.store.getBoolValueForKey(WebPreferencesKey::blockOpenDirectoryInWebContentSandboxKey());

if (shouldBlockOpenDirectory)

sandbox_enable_state_flag("BlockOpenDirectoryInWebContentSandbox", *auditToken);

#endif // PLATFORM(MAC)

#endif // HAVE(SANDBOX_STATE_FLAGS)

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

#if ENABLE(WEBGL)

&& m_shouldRenderWebGLInGPUProcess

#if ENABLE(TILED_CA_DRAWING_AREA)

&& m_drawingAreaType == DrawingAreaType::RemoteLayerTree

#endif

#endif

&& m_shouldRenderCanvasInGPUProcess

&& m_shouldRenderDOMInGPUProcess

&& m_shouldPlayMediaInGPUProcess;

if (shouldBlockIOKit) {

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

sandbox_enable_state_flag("BlockIOKitInWebContentSandbox", *auditToken);

#endif

ProcessCapabilities::setHardwareAcceleratedDecodingDisabled(true);

ProcessCapabilities::setCanUseAcceleratedBuffers(false);

static bool disabled { false };

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

OSStatus ok = CGImageSourceDisableHardwareDecoding();

ASSERT_UNUSED(ok, ok == noErr);

}

}

#endif

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

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

ASSERT(!parameters.remotePageParameters || parameters.remotePageParameters->frameTreeParameters.frameID == parameters.mainFrameIdentifier);

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

mainFrameCreationParameters(m_mainFrame.copyRef(), frameType, parameters.initialSandboxFlags, parameters.initialReferrerPolicy),

m_mainFrame->frameID(),

frameFromIdentifier(parameters.mainFrameOpenerIdentifier),

makeUniqueRef<WebSpeechRecognitionProvider>(pageID),

WebProcess::singleton().broadcastChannelRegistry(),

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

WebModelPlayerProvider::create(*this),

WebProcess::singleton().badgeClient(),

m_historyItemClient.copyRef(),

#if ENABLE(CONTEXT_MENUS)

makeUniqueRef<WebContextMenuClient>(this),

#endif

#if ENABLE(APPLE_PAY)

WebPaymentCoordinator::create(*this),

#endif

makeUniqueRef<WebChromeClient>(*this),

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

makeUniqueRef<WebDocumentSyncClient>(*this)

#if ENABLE(WEB_AUTHN)

, DigitalCredentialsCoordinator::create(*this)

#endif

);

#if ENABLE(DRAG_SUPPORT)

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

#endif

pageConfiguration.inspectorBackendClient = makeUnique<WebInspectorBackendClient>(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 = WebSpeechSynthesisClient::create(*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 = WTF::move(parameters.applicationManifest);

#endif

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

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

#endif

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

if (parameters.webExtensionControllerParameters)

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

#endif

m_corsDisablingPatterns = WTF::move(parameters.corsDisablingPatterns);

if (!m_corsDisablingPatterns.isEmpty())

synchronizeCORSDisablingPatternsWithNetworkProcess();

pageConfiguration.corsDisablingPatterns = parseAndAllowAccessToCORSDisablingPatterns(m_corsDisablingPatterns);

pageConfiguration.maskedURLSchemes = WTF::move(parameters.maskedURLSchemes);

pageConfiguration.loadsSubresources = parameters.loadsSubresources;

pageConfiguration.allowedNetworkHosts = WTF::move(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(WTF::move(parameters.fontMachExtensionHandles));

#endif

#if PLATFORM(IOS_FAMILY)

pageConfiguration.canShowWhileLocked = parameters.canShowWhileLocked;

#endif

#if PLATFORM(VISION) && ENABLE(GAMEPAD)

pageConfiguration.gamepadAccessRequiresExplicitConsent = parameters.gamepadAccessRequiresExplicitConsent;

#endif

#if HAVE(AUDIT_TOKEN)

pageConfiguration.presentingApplicationAuditToken = parameters.presentingApplicationAuditToken ? std::optional(parameters.presentingApplicationAuditToken->auditToken()) : std::nullopt;

#endif

#if PLATFORM(COCOA)

pageConfiguration.presentingApplicationBundleIdentifier = WTF::move(parameters.presentingApplicationBundleIdentifier);

#endif

#if ENABLE(IMAGE_ANALYSIS)

pageConfiguration.imageTranslationLanguageIdentifiers = WTF::move(parameters.imageTranslationLanguageIdentifiers);

#endif

if (parameters.textManipulationParameters) {

m_textManipulationIncludesSubframes = parameters.textManipulationParameters->includeSubframes;

m_internals->textManipulationExclusionRules = WTF::move(parameters.textManipulationParameters->exclusionRules);

}

#if ENABLE(VIDEO) || ENABLE(WEB_AUDIO)

if (parameters.store.getBoolValueForKey(WebPreferencesKey::remoteMediaSessionManagerEnabledKey()) || parameters.store.getBoolValueForKey(WebPreferencesKey::siteIsolationSharedProcessEnabledKey())) {

pageConfiguration.mediaSessionManagerFactory = [weakThis = WeakPtr { *this }](PageIdentifier) -> RefPtr<MediaSessionManagerInterface> {

RefPtr protectedThis = weakThis.get();

if (!protectedThis)

return nullptr;

// FIXME: This is often null with site isolation enabled. It seems like this is not what was intended.

RefPtr topDocument = protectedThis->localTopDocument();

if (!topDocument)

return nullptr;

RefPtr topCorePage = topDocument->page();

if (!topCorePage)

return nullptr;

RefPtr topWebPage = WebPage::fromCorePage(*topCorePage);

if (!topWebPage)

return nullptr;

RefPtr<PlatformMediaSessionManager> manager = RemoteMediaSessionManager::create(*topWebPage, *protectedThis);

manager->resetRestrictions();

return manager;

};

}

#endif

Ref page = Page::create(WTF::move(pageConfiguration));

m_page = page.copyRef();

updateAfterDrawingAreaCreation(parameters);

if (parameters.displayID)

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

WebStorageNamespaceProvider::incrementUseCount(sessionStorageNamespaceIdentifier());

updatePreferences(parameters.store);

if (page->settings().siteIsolationEnabled()) {

if (RefPtr frame = page->localMainFrame())

frame->inspectorController().siteIsolationFirstEnabled();

}

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

page->setDeviceScaleFactor(parameters.deviceScaleFactor);

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

setIntrinsicDeviceScaleFactor(parameters.intrinsicDeviceScaleFactor);

#endif

#if USE(SKIA)

FontRenderOptions::singleton().setUseSubpixelPositioning(parameters.deviceScaleFactor >= 2.);

#endif

RefPtr drawingArea = m_drawingArea;

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

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

drawingArea->sendEnterAcceleratedCompositingModeIfNeeded();

#endif

drawingArea->setShouldScaleViewToFitDocument(parameters.shouldScaleViewToFitDocument);

if (parameters.isProcessSwap)

freezeLayerTree(LayerTreeFreezeReason::ProcessSwap);

#if ENABLE(ASYNC_SCROLLING)

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

if (!drawingArea->supportsAsyncScrolling())

m_useAsyncScrolling = false;