/*

* Copyright (C) 2010-2021 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 "DataReference.h"

#include "DragControllerAction.h"

#include "DrawingArea.h"

#include "DrawingAreaMessages.h"

#include "EditorState.h"

#include "EventDispatcher.h"

#include "FindController.h"

#include "FormDataReference.h"

#include "FrameTreeNodeData.h"

#include "GeolocationPermissionRequestManager.h"

#include "InjectUserScriptImmediately.h"

#include "InjectedBundle.h"

#include "InjectedBundleScriptWorld.h"

#include "LibWebRTCProvider.h"

#include "LoadParameters.h"

#include "Logging.h"

#include "MediaKeySystemPermissionRequestManager.h"

#include "MediaPlaybackState.h"

#include "MediaRecorderProvider.h"

#include "NetscapePlugin.h"

#include "NetworkConnectionToWebProcessMessages.h"

#include "NetworkProcessConnection.h"

#include "NotificationPermissionRequestManager.h"

#include "PageBanner.h"

#include "PluginProcessAttributes.h"

#include "PluginProxy.h"

#include "PluginView.h"

#include "PrintInfo.h"

#include "RemoteRenderingBackendProxy.h"

#include "RemoteWebInspectorUI.h"

#include "RemoteWebInspectorUIMessages.h"

#include "SessionState.h"

#include "SessionStateConversion.h"

#include "ShareableBitmap.h"

#include "ShareableBitmapUtilities.h"

#include "SharedBufferDataReference.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 "WebBackForwardListItem.h"

#include "WebBackForwardListProxy.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 "WebDataListSuggestionPicker.h"

#include "WebDatabaseProvider.h"

#include "WebDateTimeChooser.h"

#include "WebDiagnosticLoggingClient.h"

#include "WebDocumentLoader.h"

#include "WebDragClient.h"

#include "WebEditorClient.h"

#include "WebEventConversion.h"

#include "WebEventFactory.h"

#include "WebFrame.h"

#include "WebFrameLoaderClient.h"

#include "WebFullScreenManager.h"

#include "WebFullScreenManagerMessages.h"

#include "WebGamepadProvider.h"

#include "WebGeolocationClient.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 "WebMediaKeyStorageManager.h"

#include "WebMediaKeySystemClient.h"

#include "WebMediaStrategy.h"

#include "WebMouseEvent.h"

#include "WebNotificationClient.h"

#include "WebOpenPanelResultListener.h"

#include "WebPageCreationParameters.h"

#include "WebPageGroupProxy.h"

#include "WebPageInspectorTargetController.h"

#include "WebPageMessages.h"

#include "WebPageOverlay.h"

#include "WebPageProxyMessages.h"

#include "WebPaymentCoordinator.h"

#include "WebPerformanceLoggingClient.h"

#include "WebPermissionController.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 "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 <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/ApplicationCacheStorage.h>

#include <WebCore/ArchiveResource.h>

#include <WebCore/BackForwardCache.h>

#include <WebCore/BackForwardController.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/DOMPasteAccess.h>

#include <WebCore/DataTransfer.h>

#include <WebCore/DatabaseManager.h>

#include <WebCore/DeprecatedGlobalSettings.h>

#include <WebCore/Document.h>

#include <WebCore/DocumentFragment.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/EventHandler.h>

#include <WebCore/EventNames.h>

#include <WebCore/File.h>

#include <WebCore/FocusController.h>

#include <WebCore/FontAttributeChanges.h>

#include <WebCore/FontAttributes.h>

#include <WebCore/FormState.h>

#include <WebCore/Frame.h>

#include <WebCore/FrameLoadRequest.h>

#include <WebCore/FrameLoaderTypes.h>

#include <WebCore/FrameView.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/HTMLMenuElement.h>

#include <WebCore/HTMLMenuItemElement.h>

#include <WebCore/HTMLPlugInElement.h>

#include <WebCore/HTMLSelectElement.h>

#include <WebCore/HTMLTextFormControlElement.h>

#include <WebCore/Highlight.h>

#include <WebCore/HighlightRegister.h>

#include <WebCore/HistoryController.h>

#include <WebCore/HistoryItem.h>

#include <WebCore/HitTestResult.h>

#include <WebCore/InspectorController.h>

#include <WebCore/JSDOMExceptionHandling.h>

#include <WebCore/JSDOMWindow.h>

#include <WebCore/KeyboardEvent.h>

#include <WebCore/LegacySchemeRegistry.h>

#include <WebCore/LocalizedStrings.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/MouseEvent.h>

#include <WebCore/NotImplemented.h>

#include <WebCore/Page.h>

#include <WebCore/PageConfiguration.h>

#include <WebCore/PingLoader.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/PlatformMediaSessionManager.h>

#include <WebCore/PlatformStrategies.h>

#include <WebCore/PluginDocument.h>

#include <WebCore/PointerCaptureController.h>

#include <WebCore/PrintContext.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/RenderImage.h>

#include <WebCore/RenderLayer.h>

#include <WebCore/RenderTheme.h>

#include <WebCore/RenderTreeAsText.h>

#include <WebCore/RenderView.h>

#include <WebCore/ReportingEndpointsCache.h>

#include <WebCore/ResourceLoadStatistics.h>

#include <WebCore/ResourceRequest.h>

#include <WebCore/ResourceResponse.h>

#include <WebCore/RunJavaScriptParameters.h>

#include <WebCore/RuntimeEnabledFeatures.h>

#include <WebCore/SWClientConnection.h>

#include <WebCore/ScriptController.h>

#include <WebCore/SecurityPolicy.h>

#include <WebCore/SelectionRestorationMode.h>

#include <WebCore/SerializedScriptValue.h>

#include <WebCore/Settings.h>

#include <WebCore/ShadowRoot.h>

#include <WebCore/SharedBuffer.h>

#include <WebCore/StaticRange.h>

#include <WebCore/StyleProperties.h>

#include <WebCore/SubframeLoader.h>

#include <WebCore/SubstituteData.h>

#include <WebCore/TextIterator.h>

#include <WebCore/TranslationContextMenuInfo.h>

#include <WebCore/UserContentURLPattern.h>

#include <WebCore/UserGestureIndicator.h>

#include <WebCore/UserInputBridge.h>

#include <WebCore/UserScript.h>

#include <WebCore/UserStyleSheet.h>

#include <WebCore/UserTypingGestureIndicator.h>

#include <WebCore/VisiblePosition.h>

#include <WebCore/VisibleUnits.h>

#include <WebCore/WebGLStateTracker.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(ARKIT_INLINE_PREVIEW)

#include <WebCore/HTMLModelElement.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 "PDFPlugin.h"

#include "PlaybackSessionManager.h"

#include "RemoteLayerTreeTransaction.h"

#include "RemoteObjectRegistryMessages.h"

#include "TextCheckingControllerProxy.h"

#include "UserMediaCaptureManager.h"

#include "VideoFullscreenManager.h"

#include "WKStringCF.h"

#include "WebRemoteObjectRegistry.h"

#include <WebCore/LegacyWebArchive.h>

#include <WebCore/UTIRegistry.h>

#include <wtf/MachSendRight.h>

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

#endif

#if HAVE(TOUCH_BAR)

#include "TouchBarMenuData.h"

#include "TouchBarMenuItemData.h"

#endif

#if PLATFORM(GTK)

#include "GtkSettingsManagerProxy.h"

#include "WebPrintOperationGtk.h"

#include <WebCore/SelectionData.h>

#include <gtk/gtk.h>

#endif

#if PLATFORM(IOS_FAMILY)

#include "InteractionInformationAtPosition.h"

#include "InteractionInformationRequest.h"

#include "RemoteLayerTreeDrawingArea.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(VIDEO) && USE(GSTREAMER)

#include <WebCore/MediaPlayerRequestInstallMissingPluginsCallback.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 PLATFORM(IOS)

#include "WebPreferencesDefaultValuesIOS.h"

#endif

#if USE(CG)

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

#include <WebCore/GraphicsContextCG.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 };

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

public:

~SendStopResponsivenessTimer()

{

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

}

};

class DeferredPageDestructor {

public:

static void createDeferredPageDestructor(std::unique_ptr<Page> page, WebPage* webPage)

{

new DeferredPageDestructor(WTFMove(page), webPage);

}

private:

DeferredPageDestructor(std::unique_ptr<Page> page, WebPage* webPage)

: m_page(WTFMove(page))

, m_webPage(webPage)

{

tryDestruction();

}

void tryDestruction()

{

if (m_page->insideNestedRunLoop()) {

m_page->whenUnnested([this] { tryDestruction(); });

return;

}

m_page = nullptr;

m_webPage = nullptr;

delete this;

}

std::unique_ptr<Page> m_page;

RefPtr<WebPage> m_webPage;

};

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

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

{

Ref<WebPage> page = adoptRef(*new WebPage(pageID, WTFMove(parameters)));

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

WebProcess::singleton().injectedBundle()->didCreatePage(page.ptr());

return page;

}

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

{

Vector<UserContentURLPattern> parsedPatterns;

parsedPatterns.reserveInitialCapacity(input.size());

for (const auto& pattern : input) {

UserContentURLPattern parsedPattern(pattern);

if (parsedPattern.isValid()) {

WebCore::SecurityPolicy::allowAccessTo(parsedPattern);

parsedPatterns.uncheckedAppend(WTFMove(parsedPattern));

}

}

parsedPatterns.shrinkToFit();

return parsedPatterns;

}

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

: m_identifier(pageID)

, m_mainFrame(WebFrame::create())

, m_viewSize(parameters.viewSize)

, 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

, m_layerHostingMode(parameters.layerHostingMode)

#if ENABLE(PLATFORM_DRIVEN_TEXT_CHECKING)

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

#endif

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

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

#elif ENABLE(ACCESSIBILITY) && PLATFORM(GTK)

, m_accessibilityObject(nullptr)

#endif

#if PLATFORM(WIN)

, 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_inspectorTargetController(makeUnique<WebPageInspectorTargetController>(*this))

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

#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 ENABLE(META_VIEWPORT)

, m_forceAlwaysUserScalable(parameters.ignoresViewportScaleLimits)

#endif

#if PLATFORM(IOS_FAMILY)

, m_screenSize(parameters.screenSize)

, m_availableScreenSize(parameters.availableScreenSize)

, m_overrideScreenSize(parameters.overrideScreenSize)

, m_deviceOrientation(parameters.deviceOrientation)

, m_keyboardIsAttached(parameters.keyboardIsAttached)

, m_canShowWhileLocked(parameters.canShowWhileLocked)

#endif

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

, m_activityState(parameters.activityState)

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

, 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 ENABLE(APP_BOUND_DOMAINS)

, m_limitsNavigationsToAppBoundDomains(parameters.limitsNavigationsToAppBoundDomains)

#endif

, m_lastNavigationWasAppInitiated(parameters.lastNavigationWasAppInitiated)

#if ENABLE(APP_HIGHLIGHTS)

, m_appHighlightsVisible(parameters.appHighlightsVisible)

#endif

{

ASSERT(m_identifier);

WEBPAGE_RELEASE_LOG(Loading, "constructor:");

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

PageConfiguration pageConfiguration(

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

makeUniqueRef<WebFrameLoaderClient>(m_mainFrame.copyRef()),

makeUniqueRef<WebSpeechRecognitionProvider>(m_identifier),

makeUniqueRef<MediaRecorderProvider>(*this),

WebProcess::singleton().broadcastChannelRegistry(),

WebPermissionController::create(*this),

makeUniqueRef<WebStorageProvider>()

);

pageConfiguration.chromeClient = new WebChromeClient(*this);

#if ENABLE(CONTEXT_MENUS)

pageConfiguration.contextMenuClient = new WebContextMenuClient(this);

#endif

#if ENABLE(DRAG_SUPPORT)

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

#endif

pageConfiguration.inspectorClient = new WebInspectorClient(this);

#if USE(AUTOCORRECTION_PANEL)

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

#endif

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

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

#if ENABLE(WEBGL)

pageConfiguration.webGLStateTracker = makeUnique<WebGLStateTracker>([this](bool isUsingHighPerformanceWebGL) {

send(Messages::WebPageProxy::SetIsUsingHighPerformanceWebGL(isUsingHighPerformanceWebGL));

});

#endif

#if ENABLE(SPEECH_SYNTHESIS)

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

#endif

#if PLATFORM(COCOA)

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

#endif

pageConfiguration.applicationCacheStorage = &WebProcess::singleton().applicationCacheStorage();

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

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

pageConfiguration.storageNamespaceProvider = WebStorageNamespaceProvider::getOrCreate(*m_pageGroup);

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

pageConfiguration.reportingEndpointsCache = &WebProcess::singleton().reportingEndpointsCache();

#if ENABLE(APPLE_PAY)

pageConfiguration.paymentCoordinatorClient = new WebPaymentCoordinator(*this);

#endif

#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

m_corsDisablingPatterns = WTFMove(parameters.corsDisablingPatterns);

if (!m_corsDisablingPatterns.isEmpty())

synchronizeCORSDisablingPatternsWithNetworkProcess();

pageConfiguration.corsDisablingPatterns = parseAndAllowAccessToCORSDisablingPatterns(m_corsDisablingPatterns);

pageConfiguration.userScriptsShouldWaitUntilNotification = parameters.userScriptsShouldWaitUntilNotification;

pageConfiguration.loadsSubresources = parameters.loadsSubresources;

pageConfiguration.allowedNetworkHosts = parameters.allowedNetworkHosts;

pageConfiguration.shouldRelaxThirdPartyCookieBlocking = parameters.shouldRelaxThirdPartyCookieBlocking;

pageConfiguration.httpsUpgradeEnabled = parameters.httpsUpgradeEnabled;

if (!parameters.crossOriginAccessControlCheckEnabled)

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

#if ENABLE(ATTACHMENT_ELEMENT)

if (parameters.attachmentElementExtensionHandles)

SandboxExtension::consumePermanently(*parameters.attachmentElementExtensionHandles);

#endif

#if PLATFORM(COCOA)

// FIXME(207716): The following should be removed when the GPU process is complete.

static bool hasConsumedMediaExtensionHandles = false;

if (!hasConsumedMediaExtensionHandles && parameters.mediaExtensionHandles.size()) {

SandboxExtension::consumePermanently(parameters.mediaExtensionHandles);

SandboxExtension::consumePermanently(parameters.mediaIOKitExtensionHandles);

hasConsumedMediaExtensionHandles = true;

}

static bool hasConsumedGPUExtensionHandles = false;

if (!hasConsumedGPUExtensionHandles) {

SandboxExtension::consumePermanently(parameters.gpuIOKitExtensionHandles);

SandboxExtension::consumePermanently(parameters.gpuMachExtensionHandles);

hasConsumedGPUExtensionHandles = true;

}

#endif

#if HAVE(STATIC_FONT_REGISTRY)

if (parameters.fontMachExtensionHandle)

WebProcess::singleton().switchFromStaticFontRegistryToUserFontRegistry(WTFMove(*parameters.fontMachExtensionHandle));

#endif

m_page = makeUnique<Page>(WTFMove(pageConfiguration));

#if PLATFORM(IOS)

setAllowsDeprecatedSynchronousXMLHttpRequestDuringUnload(parameters.allowsDeprecatedSynchronousXMLHttpRequestDuringUnload);

#endif

updatePreferences(parameters.store);

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

DeprecatedGlobalSettings::setShouldManageAudioSessionCategory(true);

#endif

m_backgroundColor = parameters.backgroundColor;

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

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

m_drawingArea->updatePreferences(parameters.store);

setBackgroundExtendsBeyondPage(parameters.backgroundExtendsBeyondPage);

setPageAndTextZoomFactors(parameters.pageZoomFactor, parameters.textZoomFactor);

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

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

m_page->setDeviceScaleFactor(parameters.deviceScaleFactor);

m_page->setUserInterfaceLayoutDirection(m_userInterfaceLayoutDirection);

#if PLATFORM(IOS_FAMILY)

m_page->setTextAutosizingWidth(parameters.textAutosizingWidth);

setOverrideViewportArguments(parameters.overrideViewportArguments);

#endif

platformInitialize();

setUseFixedLayout(parameters.useFixedLayout);

setUnderlayColor(parameters.underlayColor);

setPaginationMode(parameters.paginationMode);

setPaginationBehavesLikeColumns(parameters.paginationBehavesLikeColumns);

setPageLength(parameters.pageLength);

setGapBetweenPages(parameters.gapBetweenPages);

setPaginationLineGridEnabled(parameters.paginationLineGridEnabled);

#if PLATFORM(GTK)

GtkSettingsManagerProxy::singleton().applySettings(WTFMove(parameters.gtkSettings));

#endif

effectiveAppearanceDidChange(parameters.useDarkAppearance, parameters.useElevatedUserInterfaceLevel);

if (parameters.isEditable)

setEditable(true);

#if PLATFORM(MAC)

setUseSystemAppearance(parameters.useSystemAppearance);

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

m_drawingArea->enablePainting();

setMediaVolume(parameters.mediaVolume);

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

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

m_page->addLayoutMilestones({ DidFirstLayout, 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)

webProcess.eventDispatcher().addScrollingTreeForPage(this);

#endif

for (auto& mimeType : parameters.mimeTypesWithCustomContentProviders)

m_mimeTypesWithCustomContentProviders.add(mimeType);

#if ENABLE(LEGACY_ENCRYPTED_MEDIA)

if (WebMediaKeyStorageManager* manager = webProcess.supplement<WebMediaKeyStorageManager>())

m_page->settings().setMediaKeysStorageDirectory(manager->mediaKeyStorageDirectory());

#endif

if (parameters.viewScaleFactor != 1)

scaleView(parameters.viewScaleFactor);

m_page->addLayoutMilestones(parameters.observedLayoutMilestones);

#if PLATFORM(COCOA)

setSmartInsertDeleteEnabled(parameters.smartInsertDeleteEnabled);

WebCore::setAdditionalSupportedImageTypes(parameters.additionalSupportedImageTypes);

#endif

#if HAVE(APP_ACCENT_COLORS)

setAccentColor(parameters.accentColor);

#endif

m_needsFontAttributes = parameters.needsFontAttributes;

#if ENABLE(WEB_RTC)

if (!parameters.iceCandidateFilteringEnabled)

m_page->disableICECandidateFiltering();

#if USE(LIBWEBRTC)

if (parameters.enumeratingAllNetworkInterfacesEnabled)

m_page->libWebRTCProvider().enableEnumeratingAllNetworkInterfaces();

#endif

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

if (auto* captureManager = WebProcess::singleton().supplement<UserMediaCaptureManager>())

captureManager->setupCaptureProcesses(parameters.shouldCaptureAudioInUIProcess, parameters.shouldCaptureAudioInGPUProcess, parameters.shouldCaptureVideoInUIProcess, parameters.shouldCaptureVideoInGPUProcess, parameters.shouldCaptureDisplayInUIProcess);

#endif

#endif

for (const auto& iterator : parameters.urlSchemeHandlers)

registerURLSchemeHandler(iterator.value, iterator.key);

for (auto& scheme : parameters.urlSchemesWithLegacyCustomProtocolHandlers)

LegacySchemeRegistry::registerURLSchemeAsHandledBySchemeHandler({ scheme });

m_userContentController->addContentWorlds(parameters.userContentControllerParameters.userContentWorlds);

m_userContentController->addUserScripts(WTFMove(parameters.userContentControllerParameters.userScripts), InjectUserScriptImmediately::No);

m_userContentController->addUserStyleSheets(parameters.userContentControllerParameters.userStyleSheets);

m_userContentController->addUserScriptMessageHandlers(parameters.userContentControllerParameters.messageHandlers);

#if ENABLE(CONTENT_EXTENSIONS)

m_userContentController->addContentRuleLists(WTFMove(parameters.userContentControllerParameters.contentRuleLists));

#endif

#if PLATFORM(IOS_FAMILY)

setViewportConfigurationViewLayoutSize(parameters.viewportConfigurationViewLayoutSize, parameters.viewportConfigurationLayoutSizeScaleFactor, parameters.viewportConfigurationMinimumEffectiveDeviceWidth);

setMaximumUnobscuredSize(parameters.maximumUnobscuredSize);

#endif

#if USE(AUDIO_SESSION)

PlatformMediaSessionManager::setShouldDeactivateAudioSession(true);

#endif

#if HAVE(VISIBILITY_PROPAGATION_VIEW)

m_contextForVisibilityPropagation = LayerHostingContext::createForExternalHostingProcess({

m_canShowWhileLocked

});

WEBPAGE_RELEASE_LOG(Process, "WebPage: Created context with ID %u for visibility propagation from UIProcess", m_contextForVisibilityPropagation->contextID());

send(Messages::WebPageProxy::DidCreateContextInWebProcessForVisibilityPropagation(m_contextForVisibilityPropagation->contextID()));

#endif // HAVE(VISIBILITY_PROPAGATION_VIEW)

#if ENABLE(IPC_TESTING_API)

m_visitedLinkTableID = parameters.visitedLinkTableID;

#endif

#if ENABLE(VP9)

PlatformMediaSessionManager::setShouldEnableVP8Decoder(parameters.shouldEnableVP8Decoder);

PlatformMediaSessionManager::setShouldEnableVP9Decoder(parameters.shouldEnableVP9Decoder);

PlatformMediaSessionManager::setShouldEnableVP9SWDecoder(parameters.shouldEnableVP9SWDecoder);

if (m_shouldPlayMediaInGPUProcess && WebProcess::singleton().existingGPUProcessConnection())

WebProcess::singleton().existingGPUProcessConnection()->enableVP9Decoders(parameters.shouldEnableVP8Decoder, parameters.shouldEnableVP9Decoder, parameters.shouldEnableVP9SWDecoder);

#endif

m_page->setCanUseCredentialStorage(parameters.canUseCredentialStorage);

updateThrottleState();

}

#if ENABLE(GPU_PROCESS)

void WebPage::gpuProcessConnectionDidBecomeAvailable(GPUProcessConnection& gpuProcessConnection)

{

#if HAVE(VISIBILITY_PROPAGATION_VIEW)

gpuProcessConnection.createVisibilityPropagationContextForPage(*this);

#else

UNUSED_PARAM(gpuProcessConnection);

#endif

}

#endif

void WebPage::requestMediaPlaybackState(CompletionHandler<void(WebKit::MediaPlaybackState)>&& completionHandler)

{

if (!m_page->mediaPlaybackExists())

return completionHandler(MediaPlaybackState::NoMediaPlayback);

if (m_page->mediaPlaybackIsPaused())

return completionHandler(MediaPlaybackState::MediaPlaybackPaused);

if (m_page->mediaPlaybackIsSuspended())

return completionHandler(MediaPlaybackState::MediaPlaybackSuspended);

completionHandler(MediaPlaybackState::MediaPlaybackPlaying);

}

void WebPage::pauseAllMediaPlayback(CompletionHandler<void()>&& completionHandler)

{

m_page->pauseAllMediaPlayback();

completionHandler();

}

void WebPage::suspendAllMediaPlayback(CompletionHandler<void()>&& completionHandler)

{

m_page->suspendAllMediaPlayback();

completionHandler();

}

void WebPage::resumeAllMediaPlayback(CompletionHandler<void()>&& completionHandler)

{

m_page->resumeAllMediaPlayback();

completionHandler();

}

void WebPage::suspendAllMediaBuffering()

{

m_page->suspendAllMediaBuffering();

}

void WebPage::resumeAllMediaBuffering()

{

m_page->resumeAllMediaBuffering();

}

void WebPage::reinitializeWebPage(WebPageCreationParameters&& parameters)

{

ASSERT(m_drawingArea);

setSize(parameters.viewSize);

// If the UIProcess created a new DrawingArea, then we need to do the same.

if (m_drawingArea->identifier() != parameters.drawingAreaIdentifier) {

auto oldDrawingArea = std::exchange(m_drawingArea, nullptr);

oldDrawingArea->removeMessageReceiverIfNeeded();

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

m_drawingArea->setShouldScaleViewToFitDocument(parameters.shouldScaleViewToFitDocument);

m_drawingArea->updatePreferences(parameters.store);

m_drawingArea->enablePainting();

m_drawingArea->adoptLayersFromDrawingArea(*oldDrawingArea);

m_drawingArea->adoptDisplayRefreshMonitorsFromDrawingArea(*oldDrawingArea);

unfreezeLayerTree(LayerTreeFreezeReason::PageSuspended);

}

setMinimumSizeForAutoLayout(parameters.minimumSizeForAutoLayout);

setSizeToContentAutoSizeMaximumSize(parameters.sizeToContentAutoSizeMaximumSize);

if (m_activityState != parameters.activityState)

setActivityState(parameters.activityState, ActivityStateChangeAsynchronous, [] { });

if (m_layerHostingMode != parameters.layerHostingMode)

setLayerHostingMode(parameters.layerHostingMode);

#if PLATFORM(GTK)

GtkSettingsManagerProxy::singleton().applySettings(WTFMove(parameters.gtkSettings));

#endif

platformReinitialize();

}

void WebPage::updateThrottleState()

{

bool isThrottleable = this->isThrottleable();

// The UserActivity prevents App Nap. So if we want to allow App Nap of the page, stop the activity.

// If the page should not be app nap'd, start it.

if (isThrottleable)

m_userActivity.stop();

else

m_userActivity.start();