From 03c46a261f8f5dc6897aeb64a287364f23787515 Mon Sep 17 00:00:00 2001 From: Linus Groh Date: Tue, 8 Mar 2022 19:37:41 +0100 Subject: [PATCH] LibWeb: Implement the WindowProxy exotic object A couple steps requiring working relationships between browsing contexts are currently FIXME'd - see #12917. --- .../Libraries/LibWeb/Bindings/WindowProxy.cpp | 267 ++++++++++++++++++ .../Libraries/LibWeb/Bindings/WindowProxy.h | 48 ++++ Userland/Libraries/LibWeb/CMakeLists.txt | 1 + Userland/Libraries/LibWeb/Forward.h | 1 + 4 files changed, 317 insertions(+) create mode 100644 Userland/Libraries/LibWeb/Bindings/WindowProxy.cpp create mode 100644 Userland/Libraries/LibWeb/Bindings/WindowProxy.h diff --git a/Userland/Libraries/LibWeb/Bindings/WindowProxy.cpp b/Userland/Libraries/LibWeb/Bindings/WindowProxy.cpp new file mode 100644 index 0000000000..82f2f80d60 --- /dev/null +++ b/Userland/Libraries/LibWeb/Bindings/WindowProxy.cpp @@ -0,0 +1,267 @@ +/* + * Copyright (c) 2022, Linus Groh + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace Web::Bindings { + +// 7.4 The WindowProxy exotic object, https://html.spec.whatwg.org/multipage/window-object.html#the-windowproxy-exotic-object +WindowProxy::WindowProxy(JS::GlobalObject& global_object, WindowObject& window) + : JS::Object(global_object, nullptr) + , m_window(&window) +{ +} + +// 7.4.1 [[GetPrototypeOf]] ( ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-getprototypeof +JS::ThrowCompletionOr WindowProxy::internal_get_prototype_of() const +{ + // 1. Let W be the value of the [[Window]] internal slot of this. + + // 2. If IsPlatformObjectSameOrigin(W) is true, then return ! OrdinaryGetPrototypeOf(W). + if (is_platform_object_same_origin(*m_window)) + return MUST(m_window->internal_get_prototype_of()); + + // 3. Return null. + return nullptr; +} + +// 7.4.2 [[SetPrototypeOf]] ( V ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-setprototypeof +JS::ThrowCompletionOr WindowProxy::internal_set_prototype_of(Object* prototype) +{ + // 1. Return ! SetImmutablePrototype(this, V). + return MUST(set_immutable_prototype(prototype)); +} + +// 7.4.3 [[IsExtensible]] ( ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-isextensible +JS::ThrowCompletionOr WindowProxy::internal_is_extensible() const +{ + // 1. Return true. + return true; +} + +// 7.4.4 [[PreventExtensions]] ( ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-preventextensions +JS::ThrowCompletionOr WindowProxy::internal_prevent_extensions() +{ + // 1. Return false. + return false; +} + +// 7.4.5 [[GetOwnProperty]] ( P ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-getownproperty +JS::ThrowCompletionOr> WindowProxy::internal_get_own_property(JS::PropertyKey const& property_key) const +{ + auto& global_object = HTML::current_global_object(); + auto& vm = global_object.vm(); + + // 1. Let W be the value of the [[Window]] internal slot of this. + + // 2. If P is an array index property name, then: + if (property_key.is_number()) { + // 1. Let index be ! ToUint32(P). + auto index = property_key.as_number(); + + // FIXME: 2. Let maxProperties be the number of document-tree child browsing contexts of W. + size_t max_properties = 0; + + // 3. Let value be undefined. + Optional value; + + // 4. If maxProperties is greater than 0 and index is less than maxProperties, then set value to the WindowProxy object of the indexth document-tree child browsing context of W's browsing context, sorted in the order that their browsing context container elements were most recently inserted into W's associated Document, the WindowProxy object of the most recently inserted browsing context container's nested browsing context being last. + if (max_properties > 0 && index < max_properties) { + // FIXME: Implement this. + } + + // 5. If value is undefined, then: + if (!value.has_value()) { + // 1. If IsPlatformObjectSameOrigin(W) is true, then return undefined. + if (is_platform_object_same_origin(*m_window)) + return Optional {}; + + // 2. Throw a "SecurityError" DOMException. + return vm.throw_completion(global_object, DOM::SecurityError::create(String::formatted("Can't access property '{}' on cross-origin object", property_key))); + } + + // 6. Return PropertyDescriptor{ [[Value]]: value, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: true }. + return JS::PropertyDescriptor { .value = move(value), .writable = false, .enumerable = true, .configurable = true }; + } + + // 3. If IsPlatformObjectSameOrigin(W) is true, then return ! OrdinaryGetOwnProperty(W, P). + // NOTE: This is a willful violation of the JavaScript specification's invariants of the essential internal methods to maintain compatibility with existing web content. See tc39/ecma262 issue #672 for more information. + if (is_platform_object_same_origin(*m_window)) + return m_window->internal_get_own_property(property_key); + + // 4. Let property be CrossOriginGetOwnPropertyHelper(W, P). + auto property = cross_origin_get_own_property_helper(m_window, property_key); + + // 5. If property is not undefined, then return property. + if (property.has_value()) + return property; + + // FIXME: 6. If property is undefined and P is in W's document-tree child browsing context name property set, then: + if (false) { + // FIXME: 1. Let value be the WindowProxy object of the named object of W with the name P. + auto value = JS::js_undefined(); + + // 2. Return PropertyDescriptor{ [[Value]]: value, [[Enumerable]]: false, [[Writable]]: false, [[Configurable]]: true }. + // NOTE: The reason the property descriptors are non-enumerable, despite this mismatching the same-origin behavior, is for compatibility with existing web content. See issue #3183 for details. + return JS::PropertyDescriptor { .value = value, .writable = false, .enumerable = false, .configurable = true }; + } + + // 7. Return ? CrossOriginPropertyFallback(P). + return TRY(cross_origin_property_fallback(global_object, property_key)); +} + +// 7.4.6 [[DefineOwnProperty]] ( P, Desc ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-defineownproperty +JS::ThrowCompletionOr WindowProxy::internal_define_own_property(JS::PropertyKey const& property_key, JS::PropertyDescriptor const& descriptor) +{ + auto& global_object = HTML::current_global_object(); + auto& vm = global_object.vm(); + + // 1. Let W be the value of the [[Window]] internal slot of this. + + // 2. If IsPlatformObjectSameOrigin(W) is true, then: + if (is_platform_object_same_origin(*m_window)) { + // 1. If P is an array index property name, return false. + if (property_key.is_number()) + return false; + + // 2. Return ? OrdinaryDefineOwnProperty(W, P, Desc). + // NOTE: This is a willful violation of the JavaScript specification's invariants of the essential internal methods to maintain compatibility with existing web content. See tc39/ecma262 issue #672 for more information. + return m_window->internal_define_own_property(property_key, descriptor); + } + + // 3. Throw a "SecurityError" DOMException. + return vm.throw_completion(global_object, DOM::SecurityError::create(String::formatted("Can't define property '{}' on cross-origin object", property_key))); +} + +// 7.4.7 [[Get]] ( P, Receiver ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-get +JS::ThrowCompletionOr WindowProxy::internal_get(JS::PropertyKey const& property_key, JS::Value receiver) const +{ + auto& global_object = HTML::current_global_object(); + + // 1. Let W be the value of the [[Window]] internal slot of this. + + // 2. Check if an access between two browsing contexts should be reported, given the current global object's browsing context, W's browsing context, P, and the current settings object. + HTML::check_if_access_between_two_browsing_contexts_should_be_reported(*static_cast(HTML::current_global_object()).impl().browsing_context(), *m_window->impl().browsing_context(), property_key, HTML::current_settings_object()); + + // 3. If IsPlatformObjectSameOrigin(W) is true, then return ? OrdinaryGet(this, P, Receiver). + // NOTE: this is passed rather than W as OrdinaryGet and CrossOriginGet will invoke the [[GetOwnProperty]] internal method. + if (is_platform_object_same_origin(*m_window)) + return JS::Object::internal_get(property_key, receiver); + + // 4. Return ? CrossOriginGet(this, P, Receiver). + // NOTE: this is passed rather than W as OrdinaryGet and CrossOriginGet will invoke the [[GetOwnProperty]] internal method. + return cross_origin_get(global_object, *this, property_key, receiver); +} + +// 7.4.8 [[Set]] ( P, V, Receiver ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-set +JS::ThrowCompletionOr WindowProxy::internal_set(JS::PropertyKey const& property_key, JS::Value value, JS::Value receiver) +{ + auto& global_object = HTML::current_global_object(); + + // 1. Let W be the value of the [[Window]] internal slot of this. + + // 2. Check if an access between two browsing contexts should be reported, given the current global object's browsing context, W's browsing context, P, and the current settings object. + HTML::check_if_access_between_two_browsing_contexts_should_be_reported(*static_cast(HTML::current_global_object()).impl().browsing_context(), *m_window->impl().browsing_context(), property_key, HTML::current_settings_object()); + + // 3. If IsPlatformObjectSameOrigin(W) is true, then: + if (is_platform_object_same_origin(*m_window)) { + // 1. If P is an array index property name, then return false. + if (property_key.is_number()) + return false; + + // 2. Return ? OrdinarySet(W, P, V, Receiver). + return m_window->internal_set(property_key, value, receiver); + } + + // 4. Return ? CrossOriginSet(this, P, V, Receiver). + // NOTE: this is passed rather than W as CrossOriginSet will invoke the [[GetOwnProperty]] internal method. + return cross_origin_set(global_object, *this, property_key, value, receiver); +} + +// 7.4.9 [[Delete]] ( P ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-delete +JS::ThrowCompletionOr WindowProxy::internal_delete(JS::PropertyKey const& property_key) +{ + auto& global_object = HTML::current_global_object(); + auto& vm = global_object.vm(); + + // 1. Let W be the value of the [[Window]] internal slot of this. + + // 2. If IsPlatformObjectSameOrigin(W) is true, then: + if (is_platform_object_same_origin(*m_window)) { + // 1. If P is an array index property name, then: + if (property_key.is_number()) { + // 2. Let desc be ! this.[[GetOwnProperty]](P). + auto descriptor = MUST(internal_get_own_property(property_key)); + + // 2. If desc is undefined, then return true. + if (!descriptor.has_value()) + return true; + + // 3. Return false. + return false; + } + + // 2. Return ? OrdinaryDelete(W, P). + return m_window->internal_delete(property_key); + } + + // 3. Throw a "SecurityError" DOMException. + return vm.throw_completion(global_object, DOM::SecurityError::create(String::formatted("Can't delete property '{}' on cross-origin object", property_key))); +} + +// 7.4.10 [[OwnPropertyKeys]] ( ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-ownpropertykeys +JS::ThrowCompletionOr> WindowProxy::internal_own_property_keys() const +{ + auto& event_loop = HTML::main_thread_event_loop(); + auto& vm = event_loop.vm(); + + // 1. Let W be the value of the [[Window]] internal slot of this. + + // 2. Let keys be a new empty List. + auto keys = JS::MarkedVector { vm.heap() }; + + // FIXME: 3. Let maxProperties be the number of document-tree child browsing contexts of W. + size_t max_properties = 0; + + // 4. Let index be 0. + // 5. Repeat while index < maxProperties, + for (size_t i = 0; i < max_properties; ++i) { + // 1. Add ! ToString(index) as the last element of keys. + keys.append(JS::js_string(vm, String::number(i))); + + // 2. Increment index by 1. + } + + // 6. If IsPlatformObjectSameOrigin(W) is true, then return the concatenation of keys and OrdinaryOwnPropertyKeys(W). + if (is_platform_object_same_origin(*m_window)) { + keys.extend(MUST(m_window->internal_own_property_keys())); + return keys; + } + + // 7. Return the concatenation of keys and ! CrossOriginOwnPropertyKeys(W). + keys.extend(cross_origin_own_property_keys(m_window)); + return keys; +} + +void WindowProxy::visit_edges(JS::Cell::Visitor& visitor) +{ + visitor.visit(m_window); +} + +} diff --git a/Userland/Libraries/LibWeb/Bindings/WindowProxy.h b/Userland/Libraries/LibWeb/Bindings/WindowProxy.h new file mode 100644 index 0000000000..f557d12c9f --- /dev/null +++ b/Userland/Libraries/LibWeb/Bindings/WindowProxy.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2022, Linus Groh + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +#include +#include +#include + +namespace Web::Bindings { + +class WindowProxy final : public JS::Object { + JS_OBJECT(WindowProxy, JS::Object); + +public: + WindowProxy(JS::GlobalObject&, WindowObject&); + virtual ~WindowProxy() override = default; + + virtual JS::ThrowCompletionOr internal_get_prototype_of() const override; + virtual JS::ThrowCompletionOr internal_set_prototype_of(Object* prototype) override; + virtual JS::ThrowCompletionOr internal_is_extensible() const override; + virtual JS::ThrowCompletionOr internal_prevent_extensions() override; + virtual JS::ThrowCompletionOr> internal_get_own_property(JS::PropertyKey const&) const override; + virtual JS::ThrowCompletionOr internal_define_own_property(JS::PropertyKey const&, JS::PropertyDescriptor const&) override; + virtual JS::ThrowCompletionOr internal_get(JS::PropertyKey const&, JS::Value receiver) const override; + virtual JS::ThrowCompletionOr internal_set(JS::PropertyKey const&, JS::Value value, JS::Value receiver) override; + virtual JS::ThrowCompletionOr internal_delete(JS::PropertyKey const&) override; + virtual JS::ThrowCompletionOr> internal_own_property_keys() const override; + + WindowObject& window() { return *m_window; } + WindowObject const& window() const { return *m_window; } + + // NOTE: Someone will have to replace the wrapped window object as well: + // "When the browsing context is navigated, the Window object wrapped by the browsing context's associated WindowProxy object is changed." + // I haven't found where that actually happens yet. Make sure to use a Badge guarded setter. + +private: + virtual void visit_edges(JS::Cell::Visitor&) override; + + // [[Window]], https://html.spec.whatwg.org/multipage/window-object.html#concept-windowproxy-window + WindowObject* m_window { nullptr }; +}; + +} diff --git a/Userland/Libraries/LibWeb/CMakeLists.txt b/Userland/Libraries/LibWeb/CMakeLists.txt index dd9444e99f..1b16cac009 100644 --- a/Userland/Libraries/LibWeb/CMakeLists.txt +++ b/Userland/Libraries/LibWeb/CMakeLists.txt @@ -14,6 +14,7 @@ set(SOURCES Bindings/NavigatorObject.cpp Bindings/NodeWrapperFactory.cpp Bindings/WindowObject.cpp + Bindings/WindowProxy.cpp Bindings/Wrappable.cpp Crypto/Crypto.cpp Crypto/SubtleCrypto.cpp diff --git a/Userland/Libraries/LibWeb/Forward.h b/Userland/Libraries/LibWeb/Forward.h index 5db7337726..5ce0491446 100644 --- a/Userland/Libraries/LibWeb/Forward.h +++ b/Userland/Libraries/LibWeb/Forward.h @@ -515,6 +515,7 @@ class URLSearchParamsWrapper; class URLWrapper; class WebSocketWrapper; class WindowObject; +class WindowProxy; class WorkerWrapper; class WorkerGlobalScopeWrapper; class WorkerLocationWrapper;