/*

* Copyright (C) 2006-2017 Apple Inc. 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. ``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

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

#include "BackForwardController.h"

#include "BarProp.h"

#include "CSSComputedStyleDeclaration.h"

#include "CSSRule.h"

#include "CSSRuleList.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "ComposedTreeIterator.h"

#include "ContentExtensionActions.h"

#include "ContentExtensionRule.h"

#include "ContentRuleListResults.h"

#include "CrossOriginOpenerPolicy.h"

#include "Crypto.h"

#include "CustomElementRegistry.h"

#include "DOMApplicationCache.h"

#include "DOMSelection.h"

#include "DOMStringList.h"

#include "DOMTimer.h"

#include "DOMTokenList.h"

#include "DeviceMotionController.h"

#include "DeviceMotionData.h"

#include "DeviceMotionEvent.h"

#include "DeviceOrientationAndMotionAccessController.h"

#include "DeviceOrientationController.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "Editor.h"

#include "Element.h"

#include "EventHandler.h"

#include "EventListener.h"

#include "EventLoop.h"

#include "EventNames.h"

#include "FeaturePolicy.h"

#include "FloatRect.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameLoadRequest.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "HTTPParsers.h"

#include "History.h"

#include "IdleRequestOptions.h"

#include "InspectorInstrumentation.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMPromiseDeferred.h"

#include "JSDOMWindowBase.h"

#include "JSExecState.h"

#include "Location.h"

#include "MediaQueryList.h"

#include "MediaQueryMatcher.h"

#include "MessageEvent.h"

#include "MessageWithMessagePorts.h"

#include "NavigationScheduler.h"

#include "Navigator.h"

#include "Page.h"

#include "PageConsoleClient.h"

#include "PageTransitionEvent.h"

#include "Performance.h"

#include "PerformanceNavigationTiming.h"

#include "RequestAnimationFrameCallback.h"

#include "ResourceLoadInfo.h"

#include "ResourceLoadObserver.h"

#include "RuntimeApplicationChecks.h"

#include "ScheduledAction.h"

#include "Screen.h"

#include "ScrollAnimator.h"

#include "SecurityOrigin.h"

#include "SecurityOriginData.h"

#include "SecurityPolicy.h"

#include "SelectorQuery.h"

#include "SerializedScriptValue.h"

#include "Settings.h"

#include "StaticNodeList.h"

#include "Storage.h"

#include "StorageArea.h"

#include "StorageNamespace.h"

#include "StorageNamespaceProvider.h"

#include "StyleMedia.h"

#include "StyleResolver.h"

#include "StyleScope.h"

#include "SuddenTermination.h"

#include <wtf/URL.h>

#include "UserGestureIndicator.h"

#include "VisualViewport.h"

#include "WebKitPoint.h"

#include "WindowFeatures.h"

#include "WindowFocusAllowedIndicator.h"

#include "WindowProxy.h"

#include <JavaScriptCore/ScriptCallStack.h>

#include <JavaScriptCore/ScriptCallStackFactory.h>

#include <algorithm>

#include <memory>

#include <wtf/IsoMallocInlines.h>

#include <wtf/Language.h>

#include <wtf/MainThread.h>

#include <wtf/MathExtras.h>

#include <wtf/NeverDestroyed.h>

#include <wtf/Ref.h>

#include <wtf/SetForScope.h>

#include <wtf/Variant.h>

#include <wtf/text/WTFString.h>

#if ENABLE(USER_MESSAGE_HANDLERS)

#include "UserContentController.h"

#include "UserMessageHandlerDescriptor.h"

#include "WebKitNamespace.h"

#endif

#if ENABLE(GAMEPAD)

#include "GamepadManager.h"

#endif

#if ENABLE(GEOLOCATION)

#include "NavigatorGeolocation.h"

#endif

#if ENABLE(POINTER_LOCK)

#include "PointerLockController.h"

#endif

namespace WebCore {

using namespace Inspector;

static const Seconds defaultTransientActivationDuration { 2_s };

static std::optional<Seconds>& transientActivationDurationOverrideForTesting()

{

static NeverDestroyed<std::optional<Seconds>> overrideForTesting;

return overrideForTesting;

}

static Seconds transientActivationDuration()

{

if (auto override = transientActivationDurationOverrideForTesting())

return *override;

return defaultTransientActivationDuration;

}

WTF_MAKE_ISO_ALLOCATED_IMPL(DOMWindow);

typedef HashCountedSet<DOMWindow*> DOMWindowSet;

static DOMWindowSet& windowsWithUnloadEventListeners()

{

static NeverDestroyed<DOMWindowSet> windowsWithUnloadEventListeners;

return windowsWithUnloadEventListeners;

}

static DOMWindowSet& windowsWithBeforeUnloadEventListeners()

{

static NeverDestroyed<DOMWindowSet> windowsWithBeforeUnloadEventListeners;

return windowsWithBeforeUnloadEventListeners;

}

static void addUnloadEventListener(DOMWindow* domWindow)

{

if (windowsWithUnloadEventListeners().add(domWindow).isNewEntry)

domWindow->disableSuddenTermination();

}

static void removeUnloadEventListener(DOMWindow* domWindow)

{

if (windowsWithUnloadEventListeners().remove(domWindow))

domWindow->enableSuddenTermination();

}

static void removeAllUnloadEventListeners(DOMWindow* domWindow)

{

if (windowsWithUnloadEventListeners().removeAll(domWindow))

domWindow->enableSuddenTermination();

}

static void addBeforeUnloadEventListener(DOMWindow* domWindow)

{

if (windowsWithBeforeUnloadEventListeners().add(domWindow).isNewEntry)

domWindow->disableSuddenTermination();

}

static void removeBeforeUnloadEventListener(DOMWindow* domWindow)

{

if (windowsWithBeforeUnloadEventListeners().remove(domWindow))

domWindow->enableSuddenTermination();

}

static void removeAllBeforeUnloadEventListeners(DOMWindow* domWindow)

{

if (windowsWithBeforeUnloadEventListeners().removeAll(domWindow))

domWindow->enableSuddenTermination();

}

static bool allowsBeforeUnloadListeners(DOMWindow* window)

{

ASSERT_ARG(window, window);

Frame* frame = window->frame();

if (!frame)

return false;

if (!frame->page())

return false;

return frame->isMainFrame();

}

bool DOMWindow::dispatchAllPendingBeforeUnloadEvents()

{

DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();

if (set.isEmpty())

return true;

static bool alreadyDispatched = false;

ASSERT(!alreadyDispatched);

if (alreadyDispatched)

return true;

Vector<Ref<DOMWindow>> windows;

windows.reserveInitialCapacity(set.size());

for (auto& window : set)

windows.uncheckedAppend(*window.key);

for (auto& window : windows) {

if (!set.contains(window.ptr()))

continue;

RefPtr frame = window->frame();

if (!frame)

continue;

if (!frame->loader().shouldClose())

return false;

window->enableSuddenTermination();

}

alreadyDispatched = true;

return true;

}

unsigned DOMWindow::pendingUnloadEventListeners() const

{

return windowsWithUnloadEventListeners().count(const_cast<DOMWindow*>(this));

}

void DOMWindow::dispatchAllPendingUnloadEvents()

{

DOMWindowSet& set = windowsWithUnloadEventListeners();

if (set.isEmpty())

return;

static bool alreadyDispatched = false;

ASSERT(!alreadyDispatched);

if (alreadyDispatched)

return;

auto windows = WTF::map(set, [] (auto& keyValue) {

return Ref<DOMWindow>(*(keyValue.key));

});

for (auto& window : windows) {

if (!set.contains(window.ptr()))

continue;

window->dispatchEvent(PageTransitionEvent::create(eventNames().pagehideEvent, false), window->document());

window->dispatchEvent(Event::create(eventNames().unloadEvent, Event::CanBubble::No, Event::IsCancelable::No), window->document());

window->enableSuddenTermination();

}

alreadyDispatched = true;

}

// This function:

// 1) Validates the pending changes are not changing any value to NaN; in that case keep original value.

// 2) Constrains the window rect to the minimum window size and no bigger than the float rect's dimensions.

// 3) Constrains the window rect to within the top and left boundaries of the available screen rect.

// 4) Constrains the window rect to within the bottom and right boundaries of the available screen rect.

// 5) Translate the window rect coordinates to be within the coordinate space of the screen.

FloatRect DOMWindow::adjustWindowRect(Page& page, const FloatRect& pendingChanges)

{

FloatRect screen = screenAvailableRect(page.mainFrame().view());

FloatRect window = page.chrome().windowRect();

// Make sure we're in a valid state before adjusting dimensions.

ASSERT(std::isfinite(screen.x()));

ASSERT(std::isfinite(screen.y()));

ASSERT(std::isfinite(screen.width()));

ASSERT(std::isfinite(screen.height()));

ASSERT(std::isfinite(window.x()));

ASSERT(std::isfinite(window.y()));

ASSERT(std::isfinite(window.width()));

ASSERT(std::isfinite(window.height()));

// Update window values if new requested values are not NaN.

if (!std::isnan(pendingChanges.x()))

window.setX(pendingChanges.x());

if (!std::isnan(pendingChanges.y()))

window.setY(pendingChanges.y());

if (!std::isnan(pendingChanges.width()))

window.setWidth(pendingChanges.width());

if (!std::isnan(pendingChanges.height()))

window.setHeight(pendingChanges.height());

FloatSize minimumSize = page.chrome().client().minimumWindowSize();

window.setWidth(std::min(std::max(minimumSize.width(), window.width()), screen.width()));

window.setHeight(std::min(std::max(minimumSize.height(), window.height()), screen.height()));

// Constrain the window position within the valid screen area.

window.setX(std::max(screen.x(), std::min(window.x(), screen.maxX() - window.width())));

window.setY(std::max(screen.y(), std::min(window.y(), screen.maxY() - window.height())));

return window;

}

bool DOMWindow::allowPopUp(Frame& firstFrame)

{

if (DocumentLoader* documentLoader = firstFrame.loader().documentLoader()) {

// If pop-up policy was set during navigation, use it. If not, use the global settings.

PopUpPolicy popUpPolicy = documentLoader->popUpPolicy();

if (popUpPolicy == PopUpPolicy::Allow)

return true;

if (popUpPolicy == PopUpPolicy::Block)

return false;

}

return UserGestureIndicator::processingUserGesture()

|| firstFrame.settings().javaScriptCanOpenWindowsAutomatically();

}

bool DOMWindow::allowPopUp()

{

auto* frame = this->frame();

return frame && allowPopUp(*frame);

}

bool DOMWindow::canShowModalDialog(const Frame& frame)

{

// Override support for layout testing purposes.

if (auto* document = frame.document()) {

if (auto* window = document->domWindow()) {

if (window->m_canShowModalDialogOverride)

return window->m_canShowModalDialogOverride.value();

}

}

auto* page = frame.page();

return page && page->chrome().canRunModal();

}

static void languagesChangedCallback(void* context)

{

static_cast<DOMWindow*>(context)->languagesChanged();

}

void DOMWindow::setCanShowModalDialogOverride(bool allow)

{

m_canShowModalDialogOverride = allow;

}

DOMWindow::DOMWindow(Document& document)

: AbstractDOMWindow(GlobalWindowIdentifier { Process::identifier(), WindowIdentifier::generate() })

, ContextDestructionObserver(&document)

{

ASSERT(frame());

addLanguageChangeObserver(this, &languagesChangedCallback);

}

void DOMWindow::didSecureTransitionTo(Document& document)

{

observeContext(&document);

// The Window is being transferred from one document to another so we need to reset data

// members that store the window's document (rather than the window itself).

m_crypto = nullptr;

m_navigator = nullptr;

m_performance = nullptr;

}

void DOMWindow::prewarmLocalStorageIfNecessary()

{

auto* page = this->page();

// No need to prewarm for ephemeral sessions since the data is in memory only.

if (!page || page->usesEphemeralSession())

return;

if (!page->mainFrame().mayPrewarmLocalStorage())

return;

// This eagerly constructs the StorageArea, which will load items from disk.

auto localStorageResult = this->localStorage();

if (localStorageResult.hasException())

return;

auto* localStorage = localStorageResult.returnValue();

if (!localStorage)

return;

page->mainFrame().didPrewarmLocalStorage();

}

DOMWindow::~DOMWindow()

{

if (m_suspendedForDocumentSuspension)

willDestroyCachedFrame();

else

willDestroyDocumentInFrame();

removeAllUnloadEventListeners(this);

removeAllBeforeUnloadEventListeners(this);

#if ENABLE(GAMEPAD)

if (m_gamepadEventListenerCount)

GamepadManager::singleton().unregisterDOMWindow(this);

#endif

removeLanguageChangeObserver(this);

}

RefPtr<MediaQueryList> DOMWindow::matchMedia(const String& media)

{

return document() ? document()->mediaQueryMatcher().matchMedia(media) : nullptr;

}

Page* DOMWindow::page() const

{

return frame() ? frame()->page() : nullptr;

}

void DOMWindow::frameDestroyed()

{

Ref<DOMWindow> protectedThis(*this);

willDestroyDocumentInFrame();

JSDOMWindowBase::fireFrameClearedWatchpointsForWindow(this);

}

void DOMWindow::willDestroyCachedFrame()

{

// It is necessary to copy m_observers to a separate vector because the Observer may

// unregister themselves from the DOMWindow as a result of the call to willDestroyGlobalObjectInCachedFrame.

for (auto* observer : copyToVector(m_observers)) {

if (m_observers.contains(observer))

observer->willDestroyGlobalObjectInCachedFrame();

}

}

void DOMWindow::willDestroyDocumentInFrame()

{

// It is necessary to copy m_observers to a separate vector because the Observer may

// unregister themselves from the DOMWindow as a result of the call to willDestroyGlobalObjectInFrame.

for (auto* observer : copyToVector(m_observers)) {

if (m_observers.contains(observer))

observer->willDestroyGlobalObjectInFrame();

}

}

void DOMWindow::willDetachDocumentFromFrame()

{

if (!frame())

return;

RELEASE_ASSERT(!m_isSuspendingObservers);

// It is necessary to copy m_observers to a separate vector because the Observer may

// unregister themselves from the DOMWindow as a result of the call to willDetachGlobalObjectFromFrame.

for (auto& observer : copyToVector(m_observers)) {

if (m_observers.contains(observer))

observer->willDetachGlobalObjectFromFrame();

}

if (m_performance)

m_performance->clearResourceTimings();

JSDOMWindowBase::fireFrameClearedWatchpointsForWindow(this);

InspectorInstrumentation::frameWindowDiscarded(*frame(), this);

}

#if ENABLE(GAMEPAD)

void DOMWindow::incrementGamepadEventListenerCount()

{

if (++m_gamepadEventListenerCount == 1)

GamepadManager::singleton().registerDOMWindow(this);

}

void DOMWindow::decrementGamepadEventListenerCount()

{

ASSERT(m_gamepadEventListenerCount);

if (!--m_gamepadEventListenerCount)

GamepadManager::singleton().unregisterDOMWindow(this);

}

#endif

void DOMWindow::registerObserver(Observer& observer)

{

m_observers.add(&observer);

}

void DOMWindow::unregisterObserver(Observer& observer)

{

m_observers.remove(&observer);

}

void DOMWindow::resetUnlessSuspendedForDocumentSuspension()

{

if (m_suspendedForDocumentSuspension)

return;

willDestroyDocumentInFrame();

}

void DOMWindow::suspendForBackForwardCache()

{

SetForScope<bool> isSuspendingObservers(m_isSuspendingObservers, true);

RELEASE_ASSERT(frame());

for (auto* observer : copyToVector(m_observers)) {

if (m_observers.contains(observer))

observer->suspendForBackForwardCache();

}

RELEASE_ASSERT(frame());

m_suspendedForDocumentSuspension = true;

}

void DOMWindow::resumeFromBackForwardCache()

{

for (auto* observer : copyToVector(m_observers)) {

if (m_observers.contains(observer))

observer->resumeFromBackForwardCache();

}

m_suspendedForDocumentSuspension = false;

}

bool DOMWindow::isCurrentlyDisplayedInFrame() const

{

auto* frame = this->frame();

return frame && frame->document()->domWindow() == this;

}

CustomElementRegistry& DOMWindow::ensureCustomElementRegistry()

{

if (!m_customElementRegistry)

m_customElementRegistry = CustomElementRegistry::create(*this, scriptExecutionContext());

return *m_customElementRegistry;

}

static ExceptionOr<SelectorQuery&> selectorQueryInFrame(Frame* frame, const String& selectors)

{

if (!frame)

return Exception { NotSupportedError };

RefPtr document = frame->document();

if (!document)

return Exception { NotSupportedError };

return document->selectorQueryForString(selectors);

}

ExceptionOr<Ref<NodeList>> DOMWindow::collectMatchingElementsInFlatTree(Node& scope, const String& selectors)

{

auto queryOrException = selectorQueryInFrame(frame(), selectors);

if (queryOrException.hasException())

return queryOrException.releaseException();

if (!is<ContainerNode>(scope))

return Ref<NodeList> { StaticElementList::create() };

SelectorQuery& query = queryOrException.releaseReturnValue();

Vector<Ref<Element>> result;

for (auto& node : composedTreeDescendants(downcast<ContainerNode>(scope))) {

if (is<Element>(node) && query.matches(downcast<Element>(node)) && !node.isInUserAgentShadowTree())

result.append(downcast<Element>(node));

}

return Ref<NodeList> { StaticElementList::create(WTFMove(result)) };

}

ExceptionOr<RefPtr<Element>> DOMWindow::matchingElementInFlatTree(Node& scope, const String& selectors)

{

auto queryOrException = selectorQueryInFrame(frame(), selectors);

if (queryOrException.hasException())

return queryOrException.releaseException();

if (!is<ContainerNode>(scope))

return RefPtr<Element> { nullptr };

SelectorQuery& query = queryOrException.releaseReturnValue();

for (auto& node : composedTreeDescendants(downcast<ContainerNode>(scope))) {

if (is<Element>(node) && query.matches(downcast<Element>(node)) && !node.isInUserAgentShadowTree())

return &downcast<Element>(node);

}

return RefPtr<Element> { nullptr };

}

#if ENABLE(ORIENTATION_EVENTS)

int DOMWindow::orientation() const

{

auto* frame = this->frame();

if (!frame)

return 0;

return frame->orientation();

}

#endif

Screen& DOMWindow::screen()

{

if (!m_screen)

m_screen = Screen::create(*this);

return *m_screen;

}

History& DOMWindow::history()

{

if (!m_history)

m_history = History::create(*this);

return *m_history;

}

Crypto& DOMWindow::crypto() const

{

if (!m_crypto)

m_crypto = Crypto::create(document());

ASSERT(m_crypto->scriptExecutionContext() == document());

return *m_crypto;

}

BarProp& DOMWindow::locationbar()

{

if (!m_locationbar)

m_locationbar = BarProp::create(*this, BarProp::Locationbar);

return *m_locationbar;

}

BarProp& DOMWindow::menubar()

{

if (!m_menubar)

m_menubar = BarProp::create(*this, BarProp::Menubar);

return *m_menubar;

}

BarProp& DOMWindow::personalbar()

{

if (!m_personalbar)

m_personalbar = BarProp::create(*this, BarProp::Personalbar);

return *m_personalbar;

}

BarProp& DOMWindow::scrollbars()

{

if (!m_scrollbars)

m_scrollbars = BarProp::create(*this, BarProp::Scrollbars);

return *m_scrollbars;

}

BarProp& DOMWindow::statusbar()

{

if (!m_statusbar)

m_statusbar = BarProp::create(*this, BarProp::Statusbar);

return *m_statusbar;

}

BarProp& DOMWindow::toolbar()

{

if (!m_toolbar)

m_toolbar = BarProp::create(*this, BarProp::Toolbar);

return *m_toolbar;

}

PageConsoleClient* DOMWindow::console() const

{

// FIXME: This should not return nullptr when frameless.

if (!isCurrentlyDisplayedInFrame())

return nullptr;

auto* frame = this->frame();

return frame->page() ? &frame->page()->console() : nullptr;

}

DOMApplicationCache& DOMWindow::applicationCache()

{

if (!m_applicationCache)

m_applicationCache = DOMApplicationCache::create(*this);

return *m_applicationCache;

}

Navigator& DOMWindow::navigator()

{

if (!m_navigator)

m_navigator = Navigator::create(scriptExecutionContext(), *this);

ASSERT(m_navigator->scriptExecutionContext() == document());

return *m_navigator;

}

Performance& DOMWindow::performance() const

{

if (!m_performance) {

RefPtr documentLoader = document() ? document()->loader() : nullptr;

auto timeOrigin = documentLoader ? documentLoader->timing().timeOrigin() : MonotonicTime::now();

m_performance = Performance::create(document(), timeOrigin);

}

ASSERT(m_performance->scriptExecutionContext() == document());

return *m_performance;

}

ReducedResolutionSeconds DOMWindow::nowTimestamp() const

{

return performance().nowInReducedResolutionSeconds();

}

void DOMWindow::freezeNowTimestamp()

{

m_frozenNowTimestamp = nowTimestamp();

}

void DOMWindow::unfreezeNowTimestamp()

{

m_frozenNowTimestamp = std::nullopt;

}

ReducedResolutionSeconds DOMWindow::frozenNowTimestamp() const

{

return m_frozenNowTimestamp.value_or(nowTimestamp());

}

Location& DOMWindow::location()

{

if (!m_location)

m_location = Location::create(*this);

return *m_location;

}

VisualViewport& DOMWindow::visualViewport()

{

if (!m_visualViewport)

m_visualViewport = VisualViewport::create(*this);

return *m_visualViewport;

}

#if ENABLE(USER_MESSAGE_HANDLERS)

bool DOMWindow::shouldHaveWebKitNamespaceForWorld(DOMWrapperWorld& world)

{

RefPtr frame = this->frame();

if (!frame)

return false;

auto* page = frame->page();

if (!page)

return false;

bool hasUserMessageHandler = false;

page->userContentProvider().forEachUserMessageHandler([&](const UserMessageHandlerDescriptor& descriptor) {

if (&descriptor.world() == &world) {

hasUserMessageHandler = true;

return;

}

});

return hasUserMessageHandler;

}

WebKitNamespace* DOMWindow::webkitNamespace()

{

if (!isCurrentlyDisplayedInFrame())

return nullptr;

auto* page = frame()->page();

if (!page)

return nullptr;

if (!m_webkitNamespace)

m_webkitNamespace = WebKitNamespace::create(*this, page->userContentProvider());

return m_webkitNamespace.get();

}

#endif

ExceptionOr<Storage*> DOMWindow::sessionStorage()

{

if (!isCurrentlyDisplayedInFrame())

return nullptr;

RefPtr document = this->document();

if (!document)

return nullptr;

if (!document->securityOrigin().canAccessSessionStorage(document->topOrigin()))

return Exception { SecurityError };

if (m_sessionStorage)

return m_sessionStorage.get();

auto* page = document->page();

if (!page)

return nullptr;

auto storageArea = page->sessionStorage()->storageArea(document->securityOrigin().data());

m_sessionStorage = Storage::create(*this, WTFMove(storageArea));

return m_sessionStorage.get();

}

ExceptionOr<Storage*> DOMWindow::localStorage()

{

if (!isCurrentlyDisplayedInFrame())

return nullptr;

RefPtr document = this->document();

if (!document)

return nullptr;

if (!document->securityOrigin().canAccessLocalStorage(nullptr))

return Exception { SecurityError };

auto* page = document->page();

// FIXME: We should consider supporting access/modification to local storage

// after calling window.close(). See <https://bugs.webkit.org/show_bug.cgi?id=135330>.

if (!page || !page->isClosing()) {

if (m_localStorage)

return m_localStorage.get();

}

if (!page)

return nullptr;

if (page->isClosing())

return nullptr;

if (!page->settings().localStorageEnabled())

return nullptr;

auto storageArea = page->storageNamespaceProvider().localStorageArea(*document);

m_localStorage = Storage::create(*this, WTFMove(storageArea));

return m_localStorage.get();

}

ExceptionOr<void> DOMWindow::postMessage(JSC::JSGlobalObject& lexicalGlobalObject, DOMWindow& incumbentWindow, JSC::JSValue messageValue, WindowPostMessageOptions&& options)

{

if (!isCurrentlyDisplayedInFrame())

return { };

RefPtr sourceDocument = incumbentWindow.document();

// Compute the target origin. We need to do this synchronously in order

// to generate the SyntaxError exception correctly.

RefPtr<SecurityOrigin> target;

if (options.targetOrigin == "/") {

if (!sourceDocument)

return { };

target = &sourceDocument->securityOrigin();

} else if (options.targetOrigin != "*") {

target = SecurityOrigin::createFromString(options.targetOrigin);

// It doesn't make sense target a postMessage at a unique origin

// because there's no way to represent a unique origin in a string.

if (target->isUnique())

return Exception { SyntaxError };

}

Vector<RefPtr<MessagePort>> ports;

auto messageData = SerializedScriptValue::create(lexicalGlobalObject, messageValue, WTFMove(options.transfer), ports, SerializationContext::WindowPostMessage);

if (messageData.hasException())

return messageData.releaseException();

auto disentangledPorts = MessagePort::disentanglePorts(WTFMove(ports));

if (disentangledPorts.hasException())

return disentangledPorts.releaseException();

// Capture the source of the message. We need to do this synchronously

// in order to capture the source of the message correctly.

if (!sourceDocument)

return { };

auto sourceOrigin = sourceDocument->securityOrigin().toString();

// Capture stack trace only when inspector front-end is loaded as it may be time consuming.

RefPtr<ScriptCallStack> stackTrace;

if (InspectorInstrumentation::consoleAgentEnabled(sourceDocument.get()))

stackTrace = createScriptCallStack(JSExecState::currentState());

auto postMessageIdentifier = InspectorInstrumentation::willPostMessage(*frame());

MessageWithMessagePorts message { messageData.releaseReturnValue(), disentangledPorts.releaseReturnValue() };

// Schedule the message.

RefPtr<WindowProxy> incumbentWindowProxy = incumbentWindow.frame() ? &incumbentWindow.frame()->windowProxy() : nullptr;

auto userGestureToForward = UserGestureIndicator::currentUserGesture();

document()->eventLoop().queueTask(TaskSource::PostedMessageQueue, [this, protectedThis = Ref { *this }, message = WTFMove(message), incumbentWindowProxy = WTFMove(incumbentWindowProxy), sourceOrigin = WTFMove(sourceOrigin), userGestureToForward = WTFMove(userGestureToForward), postMessageIdentifier, stackTrace = WTFMove(stackTrace), targetOrigin = WTFMove(target)]() mutable {

if (!isCurrentlyDisplayedInFrame())

return;

Ref frame = *this->frame();

if (targetOrigin) {

// Check target origin now since the target document may have changed since the timer was scheduled.

if (!targetOrigin->isSameSchemeHostPort(document()->securityOrigin())) {

if (auto* pageConsole = console()) {

auto message = makeString("Unable to post message to ", targetOrigin->toString(), ". Recipient has origin ", document()->securityOrigin().toString(), ".\n");

if (stackTrace)

pageConsole->addMessage(MessageSource::Security, MessageLevel::Error, message, *stackTrace);

else

pageConsole->addMessage(MessageSource::Security, MessageLevel::Error, message);

}

InspectorInstrumentation::didFailPostMessage(frame, postMessageIdentifier);

return;

}

}

UserGestureIndicator userGestureIndicator(userGestureToForward);

InspectorInstrumentation::willDispatchPostMessage(frame, postMessageIdentifier);

auto event = MessageEvent::create(MessagePort::entanglePorts(*document(), WTFMove(message.transferredPorts)), message.message.releaseNonNull(), sourceOrigin, { }, incumbentWindowProxy ? std::make_optional(MessageEventSource(WTFMove(incumbentWindowProxy))) : std::nullopt);

dispatchEvent(event);

InspectorInstrumentation::didDispatchPostMessage(frame, postMessageIdentifier);

});

InspectorInstrumentation::didPostMessage(*frame(), postMessageIdentifier, lexicalGlobalObject);

return { };

}

DOMSelection* DOMWindow::getSelection()

{

if (!isCurrentlyDisplayedInFrame())

return nullptr;

if (!m_selection)

m_selection = DOMSelection::create(*this);

return m_selection.get();

}

Element* DOMWindow::frameElement() const

{

RefPtr frame = this->frame();

if (!frame)

return nullptr;

return frame->ownerElement();

}

void DOMWindow::focus(DOMWindow& incumbentWindow)

{

RefPtr frame = this->frame();

RefPtr openerFrame = frame ? frame->loader().opener() : nullptr;

focus(openerFrame && openerFrame != frame && incumbentWindow.frame() == openerFrame);

}

void DOMWindow::focus(bool allowFocus)

{

RefPtr frame = this->frame();

if (!frame)

return;

Page* page = frame->page();

if (!page)

return;

allowFocus = allowFocus || WindowFocusAllowedIndicator::windowFocusAllowed() || !frame->settings().windowFocusRestricted();

// If we're a top level window, bring the window to the front.

if (frame->isMainFrame() && allowFocus)

page->chrome().focus();

if (!frame->hasHadUserInteraction() && !isSameSecurityOriginAsMainFrame())

return;