LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated

This is a monster patch that turns all EventTargets into GC-allocated
PlatformObjects. Their C++ wrapper classes are removed, and the LibJS
garbage collector is now responsible for their lifetimes.

There's a fair amount of hacks and band-aids in this patch, and we'll
have a lot of cleanup to do after this.

1 files changed, 799 insertions, 51 deletions

diff --git a/Userland/Libraries/LibWeb/HTML/Window.cpp b/Userland/Libraries/LibWeb/HTML/Window.cpp
index 7c8227bf71..fd8b068f32 100644
--- a/Userland/Libraries/LibWeb/HTML/Window.cpp
+++ b/Userland/Libraries/LibWeb/HTML/Window.cpp
@@ -5,10 +5,32 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <AK/Base64.h>
+#include <AK/String.h>
+#include <AK/Utf8View.h>
 #include <LibJS/Runtime/AbstractOperations.h>
+#include <LibJS/Runtime/Completion.h>
+#include <LibJS/Runtime/Error.h>
 #include <LibJS/Runtime/FunctionObject.h>
+#include <LibJS/Runtime/Shape.h>
+#include <LibTextCodec/Decoder.h>
+#include <LibWeb/Bindings/CSSNamespace.h>
+#include <LibWeb/Bindings/CryptoWrapper.h>
+#include <LibWeb/Bindings/EventTargetConstructor.h>
+#include <LibWeb/Bindings/EventTargetPrototype.h>
+#include <LibWeb/Bindings/ExceptionOrUtils.h>
+#include <LibWeb/Bindings/HistoryWrapper.h>
 #include <LibWeb/Bindings/IDLAbstractOperations.h>
 #include <LibWeb/Bindings/IdleDeadlineWrapper.h>
+#include <LibWeb/Bindings/LocationObject.h>
+#include <LibWeb/Bindings/NavigatorObject.h>
+#include <LibWeb/Bindings/Replaceable.h>
+#include <LibWeb/Bindings/ScreenWrapper.h>
+#include <LibWeb/Bindings/SelectionWrapper.h>
+#include <LibWeb/Bindings/StorageWrapper.h>
+#include <LibWeb/Bindings/WindowObjectHelper.h>
+#include <LibWeb/Bindings/WindowPrototype.h>
+#include <LibWeb/CSS/MediaQueryList.h>
 #include <LibWeb/CSS/Parser/Parser.h>
 #include <LibWeb/CSS/ResolvedCSSStyleDeclaration.h>
 #include <LibWeb/Crypto/Crypto.h>
@@ -16,10 +38,13 @@
 #include <LibWeb/DOM/Event.h>
 #include <LibWeb/DOM/EventDispatcher.h>
 #include <LibWeb/HTML/BrowsingContext.h>
+#include <LibWeb/HTML/EventHandler.h>
 #include <LibWeb/HTML/EventLoop/EventLoop.h>
 #include <LibWeb/HTML/MessageEvent.h>
+#include <LibWeb/HTML/Origin.h>
 #include <LibWeb/HTML/PageTransitionEvent.h>
 #include <LibWeb/HTML/Scripting/ClassicScript.h>
+#include <LibWeb/HTML/Scripting/Environments.h>
 #include <LibWeb/HTML/Scripting/ExceptionReporter.h>
 #include <LibWeb/HTML/Storage.h>
 #include <LibWeb/HTML/Timer.h>
@@ -29,6 +54,7 @@
 #include <LibWeb/Page/Page.h>
 #include <LibWeb/RequestIdleCallback/IdleDeadline.h>
 #include <LibWeb/Selection/Selection.h>
+#include <LibWeb/WebAssembly/WebAssemblyObject.h>
 
 namespace Web::HTML {
 
@@ -56,54 +82,68 @@ private:
     u32 m_handle { 0 };
 };
 
-NonnullRefPtr<Window> Window::create()
+JS::NonnullGCPtr<Window> Window::create(JS::Realm& realm)
 {
-    return adopt_ref(*new Window);
+    return *realm.heap().allocate<Window>(realm, realm);
 }
 
-NonnullRefPtr<Window> Window::create_with_document(DOM::Document& document)
+JS::NonnullGCPtr<Window> Window::create_with_document(DOM::Document& document)
 {
-    return adopt_ref(*new Window(document));
+    return *document.heap().allocate<Window>(document.shape().realm(), document);
 }
 
-Window::Window()
-    : DOM::EventTarget()
-    , m_performance(make<HighResolutionTime::Performance>(*this))
+Window::Window(JS::Realm& realm)
+    : DOM::EventTarget(realm)
     , m_crypto(Crypto::Crypto::create())
     , m_screen(CSS::Screen::create({}, *this))
 {
+    // FIXME: Should this be WindowPrototype?
 }
 
 Window::Window(DOM::Document& document)
-    : DOM::EventTarget()
+    : DOM::EventTarget(document.shape().realm())
     , m_associated_document(document)
-    , m_performance(make<HighResolutionTime::Performance>(*this))
     , m_crypto(Crypto::Crypto::create())
     , m_screen(CSS::Screen::create({}, *this))
 {
 }
 
+void Window::visit_edges(JS::Cell::Visitor& visitor)
+{
+    Base::visit_edges(visitor);
+    visitor.visit(m_associated_document.ptr());
+    visitor.visit(m_current_event.ptr());
+    visitor.visit(m_performance.ptr());
+    visitor.visit(m_location_object);
+    for (auto& it : m_prototypes)
+        visitor.visit(it.value);
+    for (auto& it : m_constructors)
+        visitor.visit(it.value);
+}
+
 Window::~Window() = default;
 
-void Window::set_wrapper(Badge<Bindings::WindowObject>, Bindings::WindowObject& wrapper)
+HighResolutionTime::Performance& Window::performance()
 {
-    m_wrapper = wrapper.make_weak_ptr();
+    if (!m_performance)
+        m_performance = heap().allocate<HighResolutionTime::Performance>(realm(), *this);
+    return *m_performance;
 }
 
-void Window::alert(String const& message)
+void Window::alert_impl(String const& message)
 {
     if (auto* page = this->page())
         page->client().page_did_request_alert(message);
 }
 
-bool Window::confirm(String const& message)
+bool Window::confirm_impl(String const& message)
 {
     if (auto* page = this->page())
         return page->client().page_did_request_confirm(message);
     return false;
 }
 
-String Window::prompt(String const& message, String const& default_)
+String Window::prompt_impl(String const& message, String const& default_)
 {
     if (auto* page = this->page())
         return page->client().page_did_request_prompt(message, default_);
@@ -111,25 +151,25 @@ String Window::prompt(String const& message, String const& default_)
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
-i32 Window::set_timeout(Bindings::TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
+i32 Window::set_timeout_impl(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
 {
     return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::No);
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
-i32 Window::set_interval(Bindings::TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
+i32 Window::set_interval_impl(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
 {
     return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::Yes);
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-cleartimeout
-void Window::clear_timeout(i32 id)
+void Window::clear_timeout_impl(i32 id)
 {
     m_timers.remove(id);
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-clearinterval
-void Window::clear_interval(i32 id)
+void Window::clear_interval_impl(i32 id)
 {
     m_timers.remove(id);
 }
@@ -140,7 +180,7 @@ void Window::deallocate_timer_id(Badge<Timer>, i32 id)
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timer-initialisation-steps
-i32 Window::run_timer_initialization_steps(Bindings::TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id)
+i32 Window::run_timer_initialization_steps(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id)
 {
     // 1. Let thisArg be global if that is a WorkerGlobalScope object; otherwise let thisArg be the WindowProxy that corresponds to global.
 
@@ -162,8 +202,8 @@ i32 Window::run_timer_initialization_steps(Bindings::TimerHandler handler, i32 t
     // 8. Assert: initiating script is not null, since this algorithm is always called from some script.
 
     // 9. Let task be a task that runs the following substeps:
-    auto task = [weak_window = make_weak_ptr(), handler = move(handler), timeout, arguments = move(arguments), repeat, id]() mutable {
-        auto window = weak_window.strong_ref();
+    auto task = [weak_window = make_weak_ptr<Window>(), handler = move(handler), timeout, arguments = move(arguments), repeat, id]() mutable {
+        JS::GCPtr<Window> window = weak_window.ptr();
         if (!window)
             return;
 
@@ -174,7 +214,7 @@ i32 Window::run_timer_initialization_steps(Bindings::TimerHandler handler, i32 t
         handler.visit(
             // 2. If handler is a Function, then invoke handler given arguments with the callback this value set to thisArg. If this throws an exception, catch it, and report the exception.
             [&](JS::Handle<Bindings::CallbackType> callback) {
-                if (auto result = Bindings::IDL::invoke_callback(*callback, window->wrapper(), arguments); result.is_error())
+                if (auto result = Bindings::IDL::invoke_callback(*callback, window.ptr(), arguments); result.is_error())
                     HTML::report_exception(result);
             },
             // 3. Otherwise:
@@ -219,12 +259,12 @@ i32 Window::run_timer_initialization_steps(Bindings::TimerHandler handler, i32 t
     // FIXME: 11. Set task's timer nesting level to nesting level.
 
     // 12. Let completionStep be an algorithm step which queues a global task on the timer task source given global to run task.
-    auto completion_step = [weak_window = make_weak_ptr(), task = move(task)]() mutable {
-        auto window = weak_window.strong_ref();
+    auto completion_step = [weak_window = make_weak_ptr<Window>(), task = move(task)]() mutable {
+        JS::GCPtr<Window> window = weak_window.ptr();
         if (!window)
             return;
 
-        HTML::queue_global_task(HTML::Task::Source::TimerTask, *window->wrapper(), move(task));
+        HTML::queue_global_task(HTML::Task::Source::TimerTask, *window, move(task));
     };
 
     // 13. Run steps after a timeout given global, "setTimeout/setInterval", timeout, completionStep, and id.
@@ -237,7 +277,7 @@ i32 Window::run_timer_initialization_steps(Bindings::TimerHandler handler, i32 t
 }
 
 // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#run-the-animation-frame-callbacks
-i32 Window::request_animation_frame(Bindings::CallbackType& js_callback)
+i32 Window::request_animation_frame_impl(Bindings::CallbackType& js_callback)
 {
     return m_animation_frame_callback_driver.add([this, js_callback = JS::make_handle(js_callback)](auto) mutable {
         // 3. Invoke callback, passing now as the only argument,
@@ -249,7 +289,7 @@ i32 Window::request_animation_frame(Bindings::CallbackType& js_callback)
     });
 }
 
-void Window::cancel_animation_frame(i32 id)
+void Window::cancel_animation_frame_impl(i32 id)
 {
     m_animation_frame_callback_driver.remove(id);
 }
@@ -284,11 +324,6 @@ bool Window::dispatch_event(DOM::Event& event)
     return DOM::EventDispatcher::dispatch(*this, event, true);
 }
 
-JS::Object* Window::create_wrapper(JS::Realm& realm)
-{
-    return &realm.global_object();
-}
-
 // https://www.w3.org/TR/cssom-view-1/#dom-window-innerwidth
 int Window::inner_width() const
 {
@@ -319,15 +354,15 @@ Page const* Window::page() const
     return associated_document().page();
 }
 
-CSS::CSSStyleDeclaration* Window::get_computed_style(DOM::Element& element) const
+CSS::CSSStyleDeclaration* Window::get_computed_style_impl(DOM::Element& element) const
 {
     return CSS::ResolvedCSSStyleDeclaration::create(element);
 }
 
-NonnullRefPtr<CSS::MediaQueryList> Window::match_media(String media)
+JS::NonnullGCPtr<CSS::MediaQueryList> Window::match_media_impl(String media)
 {
     auto media_query_list = CSS::MediaQueryList::create(associated_document(), parse_media_query_list(CSS::Parser::ParsingContext(associated_document()), media));
-    associated_document().add_media_query_list(media_query_list);
+    associated_document().add_media_query_list(*media_query_list);
     return media_query_list;
 }
 
@@ -458,7 +493,7 @@ void Window::fire_a_page_transition_event(FlyString const& event_name, bool pers
     // with the persisted attribute initialized to persisted,
     HTML::PageTransitionEventInit event_init {};
     event_init.persisted = persisted;
-    auto event = HTML::PageTransitionEvent::create(associated_document().preferred_window_object(), event_name, event_init);
+    auto event = HTML::PageTransitionEvent::create(associated_document().window(), event_name, event_init);
 
     // ...the cancelable attribute initialized to true,
     event->set_cancelable(true);
@@ -471,7 +506,7 @@ void Window::fire_a_page_transition_event(FlyString const& event_name, bool pers
 }
 
 // https://html.spec.whatwg.org/#dom-queuemicrotask
-void Window::queue_microtask(Bindings::CallbackType& callback)
+void Window::queue_microtask_impl(Bindings::CallbackType& callback)
 {
     // The queueMicrotask(callback) method must queue a microtask to invoke callback,
     HTML::queue_a_microtask(&associated_document(), [callback = JS::make_handle(callback)]() mutable {
@@ -505,7 +540,7 @@ int Window::screen_y() const
 }
 
 // https://w3c.github.io/selection-api/#dom-window-getselection
-Selection::Selection* Window::get_selection()
+Selection::Selection* Window::get_selection_impl()
 {
     // FIXME: Implement.
     return nullptr;
@@ -559,17 +594,15 @@ Window* Window::parent()
 }
 
 // https://html.spec.whatwg.org/multipage/web-messaging.html#window-post-message-steps
-DOM::ExceptionOr<void> Window::post_message(JS::Value message, String const&)
+DOM::ExceptionOr<void> Window::post_message_impl(JS::Value message, String const&)
 {
     // FIXME: This is an ad-hoc hack implementation instead, since we don't currently
     //        have serialization and deserialization of messages.
-    HTML::queue_global_task(HTML::Task::Source::PostedMessage, *wrapper(), [strong_this = NonnullRefPtr(*this), message]() mutable {
+    HTML::queue_global_task(HTML::Task::Source::PostedMessage, *this, [strong_this = JS::make_handle(*this), message]() mutable {
         HTML::MessageEventInit event_init {};
         event_init.data = message;
         event_init.origin = "<origin>";
-        auto* wrapper = static_cast<Bindings::WindowObject*>(strong_this->wrapper());
-        VERIFY(wrapper);
-        strong_this->dispatch_event(*HTML::MessageEvent::create(*wrapper, HTML::EventNames::message, event_init));
+        strong_this->dispatch_event(*HTML::MessageEvent::create(*strong_this, HTML::EventNames::message, event_init));
     });
     return {};
 }
@@ -598,8 +631,7 @@ void Window::set_name(String const& name)
 void Window::start_an_idle_period()
 {
     // 1. Optionally, if the user agent determines the idle period should be delayed, return from this algorithm.
-    if (!wrapper())
-        return;
+
     // 2. Let pending_list be window's list of idle request callbacks.
     auto& pending_list = m_idle_request_callbacks;
     // 3. Let run_list be window's list of runnable idle callbacks.
@@ -614,7 +646,7 @@ void Window::start_an_idle_period()
 
     // 5. Queue a task on the queue associated with the idle-task task source,
     //    which performs the steps defined in the invoke idle callbacks algorithm with window and getDeadline as parameters.
-    HTML::queue_global_task(HTML::Task::Source::IdleTask, *wrapper(), [window = NonnullRefPtr(*this)]() mutable {
+    HTML::queue_global_task(HTML::Task::Source::IdleTask, *this, [window = JS::make_handle(*this)]() mutable {
         window->invoke_idle_callbacks();
     });
 }
@@ -638,14 +670,14 @@ void Window::invoke_idle_callbacks()
             HTML::report_exception(result);
         // 4. If window's list of runnable idle callbacks is not empty, queue a task which performs the steps
         //    in the invoke idle callbacks algorithm with getDeadline and window as a parameters and return from this algorithm
-        HTML::queue_global_task(HTML::Task::Source::IdleTask, *wrapper(), [window = NonnullRefPtr(*this)]() mutable {
+        HTML::queue_global_task(HTML::Task::Source::IdleTask, *this, [window = JS::make_handle(*this)]() mutable {
             window->invoke_idle_callbacks();
         });
     }
 }
 
 // https://w3c.github.io/requestidlecallback/#the-requestidlecallback-method
-u32 Window::request_idle_callback(Bindings::CallbackType& callback)
+u32 Window::request_idle_callback_impl(Bindings::CallbackType& callback)
 {
     // 1. Let window be this Window object.
     auto& window = *this;
@@ -670,7 +702,7 @@ u32 Window::request_idle_callback(Bindings::CallbackType& callback)
 }
 
 // https://w3c.github.io/requestidlecallback/#the-cancelidlecallback-method
-void Window::cancel_idle_callback(u32 handle)
+void Window::cancel_idle_callback_impl(u32 handle)
 {
     // 1. Let window be this Window object.
     auto& window = *this;
@@ -687,12 +719,728 @@ void Window::cancel_idle_callback(u32 handle)
 
 void Window::set_associated_document(DOM::Document& document)
 {
-    m_associated_document = document;
+    m_associated_document = &document;
 }
 
 void Window::set_current_event(DOM::Event* event)
 {
-    m_current_event = JS::make_handle(event);
+    m_current_event = event;
+}
+
+HTML::BrowsingContext const* Window::browsing_context() const
+{
+    return m_associated_document->browsing_context();
+}
+
+HTML::BrowsingContext* Window::browsing_context()
+{
+    return m_associated_document->browsing_context();
+}
+
+void Window::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+
+    // FIXME: This is a hack..
+    realm.set_global_object(this, this);
+
+    ADD_WINDOW_OBJECT_INTERFACES;
+
+    Object::set_prototype(&ensure_web_prototype<Bindings::WindowPrototype>("Window"));
+
+    // FIXME: These should be native accessors, not properties
+    define_direct_property("window", this, JS::Attribute::Enumerable);
+    define_direct_property("frames", this, JS::Attribute::Enumerable);
+    define_direct_property("self", this, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "top", top_getter, nullptr, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "parent", parent_getter, {}, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "document", document_getter, {}, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "name", name_getter, name_setter, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "history", history_getter, {}, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "performance", performance_getter, performance_setter, JS::Attribute::Enumerable | JS::Attribute::Configurable);
+    define_native_accessor(realm, "crypto", crypto_getter, {}, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "screen", screen_getter, {}, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "innerWidth", inner_width_getter, {}, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "innerHeight", inner_height_getter, {}, JS::Attribute::Enumerable);
+    define_native_accessor(realm, "devicePixelRatio", device_pixel_ratio_getter, {}, JS::Attribute::Enumerable | JS::Attribute::Configurable);
+    u8 attr = JS::Attribute::Writable | JS::Attribute::Enumerable | JS::Attribute::Configurable;
+    define_native_function(realm, "alert", alert, 0, attr);
+    define_native_function(realm, "confirm", confirm, 0, attr);
+    define_native_function(realm, "prompt", prompt, 0, attr);
+    define_native_function(realm, "setInterval", set_interval, 1, attr);
+    define_native_function(realm, "setTimeout", set_timeout, 1, attr);
+    define_native_function(realm, "clearInterval", clear_interval, 1, attr);
+    define_native_function(realm, "clearTimeout", clear_timeout, 1, attr);
+    define_native_function(realm, "requestAnimationFrame", request_animation_frame, 1, attr);
+    define_native_function(realm, "cancelAnimationFrame", cancel_animation_frame, 1, attr);
+    define_native_function(realm, "atob", atob, 1, attr);
+    define_native_function(realm, "btoa", btoa, 1, attr);
+
+    define_native_function(realm, "queueMicrotask", queue_microtask, 1, attr);
+
+    define_native_function(realm, "requestIdleCallback", request_idle_callback, 1, attr);
+    define_native_function(realm, "cancelIdleCallback", cancel_idle_callback, 1, attr);
+
+    define_native_function(realm, "getComputedStyle", get_computed_style, 1, attr);
+    define_native_function(realm, "matchMedia", match_media, 1, attr);
+    define_native_function(realm, "getSelection", get_selection, 0, attr);
+
+    define_native_function(realm, "postMessage", post_message, 1, attr);
+
+    // FIXME: These properties should be [Replaceable] according to the spec, but [Writable+Configurable] is the closest we have.
+    define_native_accessor(realm, "scrollX", scroll_x_getter, {}, attr);
+    define_native_accessor(realm, "pageXOffset", scroll_x_getter, {}, attr);
+    define_native_accessor(realm, "scrollY", scroll_y_getter, {}, attr);
+    define_native_accessor(realm, "pageYOffset", scroll_y_getter, {}, attr);
+
+    define_native_function(realm, "scroll", scroll, 2, attr);
+    define_native_function(realm, "scrollTo", scroll, 2, attr);
+    define_native_function(realm, "scrollBy", scroll_by, 2, attr);
+
+    define_native_accessor(realm, "screenX", screen_x_getter, {}, attr);
+    define_native_accessor(realm, "screenY", screen_y_getter, {}, attr);
+    define_native_accessor(realm, "screenLeft", screen_left_getter, {}, attr);
+    define_native_accessor(realm, "screenTop", screen_top_getter, {}, attr);
+
+    define_direct_property("CSS", heap().allocate<Bindings::CSSNamespace>(realm, realm), 0);
+
+    define_native_accessor(realm, "localStorage", local_storage_getter, {}, attr);
+    define_native_accessor(realm, "sessionStorage", session_storage_getter, {}, attr);
+    define_native_accessor(realm, "origin", origin_getter, {}, attr);
+
+    // Legacy
+    define_native_accessor(realm, "event", event_getter, event_setter, JS::Attribute::Enumerable);
+
+    m_location_object = heap().allocate<Bindings::LocationObject>(realm, realm);
+
+    auto* m_navigator_object = heap().allocate<Bindings::NavigatorObject>(realm, realm);
+    define_direct_property("navigator", m_navigator_object, JS::Attribute::Enumerable | JS::Attribute::Configurable);
+    define_direct_property("clientInformation", m_navigator_object, JS::Attribute::Enumerable | JS::Attribute::Configurable);
+
+    // NOTE: location is marked as [LegacyUnforgeable], meaning it isn't configurable.
+    define_native_accessor(realm, "location", location_getter, location_setter, JS::Attribute::Enumerable);
+
+    // WebAssembly "namespace"
+    define_direct_property("WebAssembly", heap().allocate<Bindings::WebAssemblyObject>(realm, realm), JS::Attribute::Enumerable | JS::Attribute::Configurable);
+
+    // HTML::GlobalEventHandlers and HTML::WindowEventHandlers
+#define __ENUMERATE(attribute, event_name) \
+    define_native_accessor(realm, #attribute, attribute##_getter, attribute##_setter, attr);
+    ENUMERATE_GLOBAL_EVENT_HANDLERS(__ENUMERATE);
+    ENUMERATE_WINDOW_EVENT_HANDLERS(__ENUMERATE);
+#undef __ENUMERATE
+}
+
+HTML::Origin Window::origin() const
+{
+    return impl().associated_document().origin();
+}
+
+// https://webidl.spec.whatwg.org/#platform-object-setprototypeof
+JS::ThrowCompletionOr<bool> Window::internal_set_prototype_of(JS::Object* prototype)
+{
+    // 1. Return ? SetImmutablePrototype(O, V).
+    return set_immutable_prototype(prototype);
+}
+
+static JS::ThrowCompletionOr<HTML::Window*> impl_from(JS::VM& vm)
+{
+    // Since this is a non built-in function we must treat it as non-strict mode
+    // this means that a nullish this_value should be converted to the
+    // global_object. Generally this does not matter as we try to convert the
+    // this_value to a specific object type in the bindings. But since window is
+    // the global object we make an exception here.
+    // This allows calls like `setTimeout(f, 10)` to work.
+    auto this_value = vm.this_value();
+    if (this_value.is_nullish())
+        this_value = &vm.current_realm()->global_object();
+
+    auto* this_object = MUST(this_value.to_object(vm));
+
+    if (!is<Window>(*this_object))
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Window");
+    return &static_cast<Window*>(this_object)->impl();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::alert)
+{
+    // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#simple-dialogs
+    // Note: This method is defined using two overloads, instead of using an optional argument,
+    //       for historical reasons. The practical impact of this is that alert(undefined) is
+    //       treated as alert("undefined"), but alert() is treated as alert("").
+    auto* impl = TRY(impl_from(vm));
+    String message = "";
+    if (vm.argument_count())
+        message = TRY(vm.argument(0).to_string(vm));
+    impl->alert_impl(message);
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::confirm)
+{
+    auto* impl = TRY(impl_from(vm));
+    String message = "";
+    if (!vm.argument(0).is_undefined())
+        message = TRY(vm.argument(0).to_string(vm));
+    return JS::Value(impl->confirm_impl(message));
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::prompt)
+{
+    auto* impl = TRY(impl_from(vm));
+    String message = "";
+    String default_ = "";
+    if (!vm.argument(0).is_undefined())
+        message = TRY(vm.argument(0).to_string(vm));
+    if (!vm.argument(1).is_undefined())
+        default_ = TRY(vm.argument(1).to_string(vm));
+    auto response = impl->prompt_impl(message, default_);
+    if (response.is_null())
+        return JS::js_null();
+    return JS::js_string(vm, response);
+}
+
+static JS::ThrowCompletionOr<TimerHandler> make_timer_handler(JS::VM& vm, JS::Value handler)
+{
+    if (handler.is_function())
+        return JS::make_handle(vm.heap().allocate_without_realm<Bindings::CallbackType>(handler.as_function(), HTML::incumbent_settings_object()));
+    return TRY(handler.to_string(vm));
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
+JS_DEFINE_NATIVE_FUNCTION(Window::set_timeout)
+{
+    auto* impl = TRY(impl_from(vm));
+
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountAtLeastOne, "setTimeout");
+
+    auto handler = TRY(make_timer_handler(vm, vm.argument(0)));
+
+    i32 timeout = 0;
+    if (vm.argument_count() >= 2)
+        timeout = TRY(vm.argument(1).to_i32(vm));
+
+    JS::MarkedVector<JS::Value> arguments { vm.heap() };
+    for (size_t i = 2; i < vm.argument_count(); ++i)
+        arguments.append(vm.argument(i));
+
+    auto id = impl->set_timeout_impl(move(handler), timeout, move(arguments));
+    return JS::Value(id);
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
+JS_DEFINE_NATIVE_FUNCTION(Window::set_interval)
+{
+    auto* impl = TRY(impl_from(vm));
+
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountAtLeastOne, "setInterval");
+
+    auto handler = TRY(make_timer_handler(vm, vm.argument(0)));
+
+    i32 timeout = 0;
+    if (vm.argument_count() >= 2)
+        timeout = TRY(vm.argument(1).to_i32(vm));
+
+    JS::MarkedVector<JS::Value> arguments { vm.heap() };
+    for (size_t i = 2; i < vm.argument_count(); ++i)
+        arguments.append(vm.argument(i));
+
+    auto id = impl->set_interval_impl(move(handler), timeout, move(arguments));
+    return JS::Value(id);
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-cleartimeout
+JS_DEFINE_NATIVE_FUNCTION(Window::clear_timeout)
+{
+    auto* impl = TRY(impl_from(vm));
+
+    i32 id = 0;
+    if (vm.argument_count())
+        id = TRY(vm.argument(0).to_i32(vm));
+
+    impl->clear_timeout_impl(id);
+    return JS::js_undefined();
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-clearinterval
+JS_DEFINE_NATIVE_FUNCTION(Window::clear_interval)
+{
+    auto* impl = TRY(impl_from(vm));
+
+    i32 id = 0;
+    if (vm.argument_count())
+        id = TRY(vm.argument(0).to_i32(vm));
+
+    impl->clear_interval_impl(id);
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::request_animation_frame)
+{
+    auto* impl = TRY(impl_from(vm));
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountOne, "requestAnimationFrame");
+    auto* callback_object = TRY(vm.argument(0).to_object(vm));
+    if (!callback_object->is_function())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAFunctionNoParam);
+    auto* callback = vm.heap().allocate_without_realm<Bindings::CallbackType>(*callback_object, HTML::incumbent_settings_object());
+    return JS::Value(impl->request_animation_frame_impl(*callback));
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::cancel_animation_frame)
+{
+    auto* impl = TRY(impl_from(vm));
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountOne, "cancelAnimationFrame");
+    auto id = TRY(vm.argument(0).to_i32(vm));
+    impl->cancel_animation_frame_impl(id);
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::queue_microtask)
+{
+    auto* impl = TRY(impl_from(vm));
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountAtLeastOne, "queueMicrotask");
+    auto* callback_object = TRY(vm.argument(0).to_object(vm));
+    if (!callback_object->is_function())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAFunctionNoParam);
+
+    auto* callback = vm.heap().allocate_without_realm<Bindings::CallbackType>(*callback_object, HTML::incumbent_settings_object());
+
+    impl->queue_microtask_impl(*callback);
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::request_idle_callback)
+{
+    auto* impl = TRY(impl_from(vm));
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountAtLeastOne, "requestIdleCallback");
+    auto* callback_object = TRY(vm.argument(0).to_object(vm));
+    if (!callback_object->is_function())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAFunctionNoParam);
+    // FIXME: accept options object
+
+    auto* callback = vm.heap().allocate_without_realm<Bindings::CallbackType>(*callback_object, HTML::incumbent_settings_object());
+
+    return JS::Value(impl->request_idle_callback_impl(*callback));
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::cancel_idle_callback)
+{
+    auto* impl = TRY(impl_from(vm));
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountOne, "cancelIdleCallback");
+    auto id = TRY(vm.argument(0).to_u32(vm));
+    impl->cancel_idle_callback_impl(id);
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::atob)
+{
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountOne, "atob");
+    auto string = TRY(vm.argument(0).to_string(vm));
+    auto decoded = decode_base64(StringView(string));
+    if (decoded.is_error())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::InvalidFormat, "Base64");
+
+    // decode_base64() returns a byte string. LibJS uses UTF-8 for strings. Use Latin1Decoder to convert bytes 128-255 to UTF-8.
+    auto decoder = TextCodec::decoder_for("windows-1252");
+    VERIFY(decoder);
+    return JS::js_string(vm, decoder->to_utf8(decoded.value()));
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::btoa)
+{
+    if (!vm.argument_count())
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountOne, "btoa");
+    auto string = TRY(vm.argument(0).to_string(vm));
+
+    Vector<u8> byte_string;
+    byte_string.ensure_capacity(string.length());
+    for (u32 code_point : Utf8View(string)) {
+        if (code_point > 0xff) {
+            return Bindings::throw_dom_exception_if_needed(vm, [] {
+                return DOM::InvalidCharacterError::create("Data contains characters outside the range U+0000 and U+00FF");
+            }).release_error();
+        }
+        byte_string.append(code_point);
+    }
+
+    auto encoded = encode_base64(byte_string.span());
+    return JS::js_string(vm, move(encoded));
+}
+
+// https://html.spec.whatwg.org/multipage/browsers.html#dom-top
+JS_DEFINE_NATIVE_FUNCTION(Window::top_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+
+    auto* this_browsing_context = impl->associated_document().browsing_context();
+    if (!this_browsing_context)
+        return JS::js_null();
+
+    VERIFY(this_browsing_context->top_level_browsing_context().active_document());
+    auto& top_window = this_browsing_context->top_level_browsing_context().active_document()->window();
+    return &top_window;
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::parent_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    auto* parent = impl->parent();
+    if (!parent)
+        return JS::js_null();
+    return parent;
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::document_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    return wrap(realm, impl->associated_document());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::performance_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    return wrap(realm, impl->performance());
 }
 
+JS_DEFINE_NATIVE_FUNCTION(Window::performance_setter)
+{
+    // https://webidl.spec.whatwg.org/#dfn-attribute-setter
+    // 4.1. If no arguments were passed, then throw a TypeError.
+    if (vm.argument_count() == 0)
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::BadArgCountOne, "set performance");
+
+    auto* impl = TRY(impl_from(vm));
+
+    // 5. If attribute is declared with the [Replaceable] extended attribute, then:
+    // 1. Perform ? CreateDataProperty(esValue, id, V).
+    TRY(impl->create_data_property("performance", vm.argument(0)));
+
+    // 2. Return undefined.
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::screen_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    return wrap(realm, impl->screen());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::event_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    if (!impl->current_event())
+        return JS::js_undefined();
+    return wrap(realm, const_cast<DOM::Event&>(*impl->current_event()));
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::event_setter)
+{
+    REPLACEABLE_PROPERTY_SETTER(Window, event);
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::location_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return impl->m_location_object;
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::location_setter)
+{
+    auto* impl = TRY(impl_from(vm));
+    TRY(impl->m_location_object->set(JS::PropertyKey("href"), vm.argument(0), JS::Object::ShouldThrowExceptions::Yes));
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::crypto_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    return wrap(realm, impl->crypto());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::inner_width_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->inner_width());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::inner_height_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->inner_height());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::device_pixel_ratio_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->device_pixel_ratio());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::get_computed_style)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    auto* object = TRY(vm.argument(0).to_object(vm));
+    if (!is<DOM::Element>(object))
+        return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "DOM element");
+
+    return wrap(realm, *impl->get_computed_style_impl(*static_cast<DOM::Element*>(object)));
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::get_selection)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    auto* selection = impl->get_selection_impl();
+    if (!selection)
+        return JS::js_null();
+    return wrap(realm, *selection);
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::match_media)
+{
+    auto* impl = TRY(impl_from(vm));
+    auto media = TRY(vm.argument(0).to_string(vm));
+    return impl->match_media_impl(move(media));
+}
+
+// https://www.w3.org/TR/cssom-view/#dom-window-scrollx
+JS_DEFINE_NATIVE_FUNCTION(Window::scroll_x_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->scroll_x());
+}
+
+// https://www.w3.org/TR/cssom-view/#dom-window-scrolly
+JS_DEFINE_NATIVE_FUNCTION(Window::scroll_y_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->scroll_y());
+}
+
+enum class ScrollBehavior {
+    Auto,
+    Smooth
+};
+
+// https://www.w3.org/TR/cssom-view/#perform-a-scroll
+static void perform_a_scroll(Page& page, double x, double y, ScrollBehavior)
+{
+    // FIXME: Stop any existing smooth-scrolls
+    // FIXME: Implement smooth-scroll
+    page.client().page_did_request_scroll_to({ x, y });
+}
+
+// https://www.w3.org/TR/cssom-view/#dom-window-scroll
+JS_DEFINE_NATIVE_FUNCTION(Window::scroll)
+{
+    auto* impl = TRY(impl_from(vm));
+    if (!impl->page())
+        return JS::js_undefined();
+    auto& page = *impl->page();
+
+    auto viewport_rect = page.top_level_browsing_context().viewport_rect();
+    auto x_value = JS::Value(viewport_rect.x());
+    auto y_value = JS::Value(viewport_rect.y());
+    String behavior_string = "auto";
+
+    if (vm.argument_count() == 1) {
+        auto* options = TRY(vm.argument(0).to_object(vm));
+        auto left = TRY(options->get("left"));
+        if (!left.is_undefined())
+            x_value = left;
+
+        auto top = TRY(options->get("top"));
+        if (!top.is_undefined())
+            y_value = top;
+
+        auto behavior_string_value = TRY(options->get("behavior"));
+        if (!behavior_string_value.is_undefined())
+            behavior_string = TRY(behavior_string_value.to_string(vm));
+        if (behavior_string != "smooth" && behavior_string != "auto")
+            return vm.throw_completion<JS::TypeError>("Behavior is not one of 'smooth' or 'auto'");
+
+    } else if (vm.argument_count() >= 2) {
+        // We ignore arguments 2+ in line with behavior of Chrome and Firefox
+        x_value = vm.argument(0);
+        y_value = vm.argument(1);
+    }
+
+    ScrollBehavior behavior = (behavior_string == "smooth") ? ScrollBehavior::Smooth : ScrollBehavior::Auto;
+
+    double x = TRY(x_value.to_double(vm));
+    x = JS::Value(x).is_finite_number() ? x : 0.0;
+
+    double y = TRY(y_value.to_double(vm));
+    y = JS::Value(y).is_finite_number() ? y : 0.0;
+
+    // FIXME: Are we calculating the viewport in the way this function expects?
+    // FIXME: Handle overflow-directions other than top-left to bottom-right
+
+    perform_a_scroll(page, x, y, behavior);
+    return JS::js_undefined();
+}
+
+// https://www.w3.org/TR/cssom-view/#dom-window-scrollby
+JS_DEFINE_NATIVE_FUNCTION(Window::scroll_by)
+{
+    auto& realm = *vm.current_realm();
+
+    auto* impl = TRY(impl_from(vm));
+    if (!impl->page())
+        return JS::js_undefined();
+    auto& page = *impl->page();
+
+    JS::Object* options = nullptr;
+
+    if (vm.argument_count() == 0) {
+        options = JS::Object::create(realm, nullptr);
+    } else if (vm.argument_count() == 1) {
+        options = TRY(vm.argument(0).to_object(vm));
+    } else if (vm.argument_count() >= 2) {
+        // We ignore arguments 2+ in line with behavior of Chrome and Firefox
+        options = JS::Object::create(realm, nullptr);
+        MUST(options->set("left", vm.argument(0), ShouldThrowExceptions::No));
+        MUST(options->set("top", vm.argument(1), ShouldThrowExceptions::No));
+        MUST(options->set("behavior", JS::js_string(vm, "auto"), ShouldThrowExceptions::No));
+    }
+
+    auto left_value = TRY(options->get("left"));
+    auto left = TRY(left_value.to_double(vm));
+
+    auto top_value = TRY(options->get("top"));
+    auto top = TRY(top_value.to_double(vm));
+
+    left = JS::Value(left).is_finite_number() ? left : 0.0;
+    top = JS::Value(top).is_finite_number() ? top : 0.0;
+
+    auto current_scroll_position = page.top_level_browsing_context().viewport_scroll_offset();
+    left = left + current_scroll_position.x();
+    top = top + current_scroll_position.y();
+
+    auto behavior_string_value = TRY(options->get("behavior"));
+    auto behavior_string = behavior_string_value.is_undefined() ? "auto" : TRY(behavior_string_value.to_string(vm));
+    if (behavior_string != "smooth" && behavior_string != "auto")
+        return vm.throw_completion<JS::TypeError>("Behavior is not one of 'smooth' or 'auto'");
+    ScrollBehavior behavior = (behavior_string == "smooth") ? ScrollBehavior::Smooth : ScrollBehavior::Auto;
+
+    // FIXME: Spec wants us to call scroll(options) here.
+    //        The only difference is that would invoke the viewport calculations that scroll()
+    //        is not actually doing yet, so this is the same for now.
+    perform_a_scroll(page, left, top, behavior);
+    return JS::js_undefined();
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::history_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    return wrap(realm, impl->associated_document().history());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::screen_left_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->screen_x());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::screen_top_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->screen_y());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::screen_x_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->screen_x());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::screen_y_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::Value(impl->screen_y());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::post_message)
+{
+    auto* impl = TRY(impl_from(vm));
+    auto target_origin = TRY(vm.argument(1).to_string(vm));
+    impl->post_message_impl(vm.argument(0), target_origin);
+    return JS::js_undefined();
+}
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#dom-origin
+JS_DEFINE_NATIVE_FUNCTION(Window::origin_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::js_string(vm, impl->associated_document().origin().serialize());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::local_storage_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    // FIXME: localStorage may throw. We have to deal with that here.
+    return wrap(realm, *impl->local_storage());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::session_storage_getter)
+{
+    auto& realm = *vm.current_realm();
+    auto* impl = TRY(impl_from(vm));
+    // FIXME: sessionStorage may throw. We have to deal with that here.
+    return wrap(realm, *impl->session_storage());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::name_getter)
+{
+    auto* impl = TRY(impl_from(vm));
+    return JS::js_string(vm, impl->name());
+}
+
+JS_DEFINE_NATIVE_FUNCTION(Window::name_setter)
+{
+    auto* impl = TRY(impl_from(vm));
+    impl->set_name(TRY(vm.argument(0).to_string(vm)));
+    return JS::js_undefined();
+}
+
+#define __ENUMERATE(attribute, event_name)                                        \
+    JS_DEFINE_NATIVE_FUNCTION(Window::attribute##_getter)                         \
+    {                                                                             \
+        auto* impl = TRY(impl_from(vm));                                          \
+        auto retval = impl->attribute();                                          \
+        if (!retval)                                                              \
+            return JS::js_null();                                                 \
+        return &retval->callback;                                                 \
+    }                                                                             \
+    JS_DEFINE_NATIVE_FUNCTION(Window::attribute##_setter)                         \
+    {                                                                             \
+        auto* impl = TRY(impl_from(vm));                                          \
+        auto value = vm.argument(0);                                              \
+        Bindings::CallbackType* cpp_value = nullptr;                              \
+        if (value.is_object()) {                                                  \
+            cpp_value = vm.heap().allocate_without_realm<Bindings::CallbackType>( \
+                value.as_object(), HTML::incumbent_settings_object());            \
+        }                                                                         \
+        impl->set_##attribute(cpp_value);                                         \
+        return JS::js_undefined();                                                \
+    }
+ENUMERATE_GLOBAL_EVENT_HANDLERS(__ENUMERATE)
+ENUMERATE_WINDOW_EVENT_HANDLERS(__ENUMERATE)
+#undef __ENUMERATE
+
 }