0ct0pu5/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2
ladybird/Userland/Libraries/LibWeb/HTML/Window.h
Luke Wilde fc42c75a0c LibWeb: Make Window.postMessage closer to the spec 
The main issues are using Structured{Serialize,Deserailize} instead of
Structured{Serialize,Deserialize}WithTransfer and the temporary
execution context usage for StructuredDeserialize.

Allows Discord to load once again, as it uses a postMessage scheduler
to render components, including the main App component. The callback
checked the (previously) non-existent source attribute of the
MessageEvent and returned if it was not the main window.

Fixes the Twitch cookie consent banner saying "failed integrity check"
for unknown reasons, but presumably related to the source and origin
attributes.
2023-11-08 09:55:24 +01:00

280 lines
12 KiB
C++
Raw Blame History

/*
* Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Badge.h>
#include <AK/RefPtr.h>
#include <AK/TypeCasts.h>
#include <AK/URL.h>
#include <LibJS/Heap/Heap.h>
#include <LibWeb/Bindings/Intrinsics.h>
#include <LibWeb/Bindings/WindowGlobalMixin.h>
#include <LibWeb/DOM/EventTarget.h>
#include <LibWeb/Forward.h>
#include <LibWeb/HTML/AnimationFrameCallbackDriver.h>
#include <LibWeb/HTML/CrossOrigin/CrossOriginPropertyDescriptorMap.h>
#include <LibWeb/HTML/GlobalEventHandlers.h>
#include <LibWeb/HTML/MimeType.h>
#include <LibWeb/HTML/Navigable.h>
#include <LibWeb/HTML/Plugin.h>
#include <LibWeb/HTML/Scripting/ImportMap.h>
#include <LibWeb/HTML/ScrollOptions.h>
#include <LibWeb/HTML/WindowEventHandlers.h>
#include <LibWeb/HTML/WindowOrWorkerGlobalScope.h>
#include <LibWeb/RequestIdleCallback/IdleRequest.h>
namespace Web::HTML {
class IdleCallback;
// https://w3c.github.io/csswg-drafts/cssom-view/#dictdef-scrolltooptions
struct ScrollToOptions : public ScrollOptions {
Optional<double> left;
Optional<double> top;
};
// https://html.spec.whatwg.org/multipage/nav-history-apis.html#windowpostmessageoptions
struct WindowPostMessageOptions : public StructuredSerializeOptions {
String target_origin { "/"_string };
};
class Window final
: public DOM::EventTarget
, public GlobalEventHandlers
, public WindowEventHandlers
, public WindowOrWorkerGlobalScopeMixin
, public Bindings::WindowGlobalMixin {
WEB_PLATFORM_OBJECT(Window, DOM::EventTarget);
public:
[[nodiscard]] static JS::NonnullGCPtr<Window> create(JS::Realm&);
~Window();
using WindowOrWorkerGlobalScopeMixin::atob;
using WindowOrWorkerGlobalScopeMixin::btoa;
using WindowOrWorkerGlobalScopeMixin::clear_interval;
using WindowOrWorkerGlobalScopeMixin::clear_timeout;
using WindowOrWorkerGlobalScopeMixin::fetch;
using WindowOrWorkerGlobalScopeMixin::queue_microtask;
using WindowOrWorkerGlobalScopeMixin::set_interval;
using WindowOrWorkerGlobalScopeMixin::set_timeout;
using WindowOrWorkerGlobalScopeMixin::structured_clone;
// ^DOM::EventTarget
virtual bool dispatch_event(DOM::Event&) override;
// ^WindowOrWorkerGlobalScopeMixin
virtual Bindings::PlatformObject& this_impl() override { return *this; }
virtual Bindings::PlatformObject const& this_impl() const override { return *this; }
// ^JS::Object
virtual JS::ThrowCompletionOr<bool> internal_set_prototype_of(JS::Object* prototype) override;
Page* page();
Page const* page() const;
// https://html.spec.whatwg.org/multipage/window-object.html#concept-document-window
DOM::Document const& associated_document() const { return *m_associated_document; }
DOM::Document& associated_document() { return *m_associated_document; }
void set_associated_document(DOM::Document&);
// https://html.spec.whatwg.org/multipage/window-object.html#window-bc
BrowsingContext const* browsing_context() const;
BrowsingContext* browsing_context();
JS::GCPtr<Navigable> navigable() const;
ImportMap const& import_map() const { return m_import_map; }
bool import_maps_allowed() const { return m_import_maps_allowed; }
void set_import_maps_allowed(bool import_maps_allowed) { m_import_maps_allowed = import_maps_allowed; }
WebIDL::ExceptionOr<JS::GCPtr<WindowProxy>> open_impl(StringView url, StringView target, StringView features);
bool has_animation_frame_callbacks() const { return m_animation_frame_callback_driver.has_callbacks(); }
DOM::Event* current_event() { return m_current_event.ptr(); }
DOM::Event const* current_event() const { return m_current_event.ptr(); }
void set_current_event(DOM::Event* event);
Optional<CSS::MediaFeatureValue> query_media_feature(CSS::MediaFeatureID) const;
void fire_a_page_transition_event(FlyString const& event_name, bool persisted);
WebIDL::ExceptionOr<JS::NonnullGCPtr<Storage>> local_storage();
WebIDL::ExceptionOr<JS::NonnullGCPtr<Storage>> session_storage();
void start_an_idle_period();
AnimationFrameCallbackDriver& animation_frame_callback_driver() { return m_animation_frame_callback_driver; }
// https://html.spec.whatwg.org/multipage/interaction.html#transient-activation
bool has_transient_activation() const;
WebIDL::ExceptionOr<void> initialize_web_interfaces(Badge<WindowEnvironmentSettingsObject>);
Vector<JS::NonnullGCPtr<Plugin>> pdf_viewer_plugin_objects();
Vector<JS::NonnullGCPtr<MimeType>> pdf_viewer_mime_type_objects();
CrossOriginPropertyDescriptorMap const& cross_origin_property_descriptor_map() const { return m_cross_origin_property_descriptor_map; }
CrossOriginPropertyDescriptorMap& cross_origin_property_descriptor_map() { return m_cross_origin_property_descriptor_map; }
WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> count_queuing_strategy_size_function();
WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> byte_length_queuing_strategy_size_function();
// JS API functions
JS::NonnullGCPtr<WindowProxy> window() const;
JS::NonnullGCPtr<WindowProxy> self() const;
JS::NonnullGCPtr<DOM::Document const> document() const;
String name() const;
void set_name(String const&);
[[nodiscard]] JS::NonnullGCPtr<Location> location();
JS::NonnullGCPtr<History> history() const;
JS::NonnullGCPtr<Navigation> navigation();
void focus();
JS::NonnullGCPtr<WindowProxy> frames() const;
u32 length();
JS::GCPtr<WindowProxy const> top() const;
JS::GCPtr<WindowProxy const> parent() const;
JS::GCPtr<DOM::Element const> frame_element() const;
WebIDL::ExceptionOr<JS::GCPtr<WindowProxy>> open(Optional<String> const& url, Optional<String> const& target, Optional<String> const& features);
[[nodiscard]] JS::NonnullGCPtr<Navigator> navigator();
void alert(String const& message = {});
bool confirm(Optional<String> const& message);
Optional<String> prompt(Optional<String> const& message, Optional<String> const& default_);
WebIDL::ExceptionOr<void> post_message(JS::Value message, String const&, Vector<JS::Handle<JS::Object>> const&);
WebIDL::ExceptionOr<void> post_message(JS::Value message, WindowPostMessageOptions const&);
Variant<JS::Handle<DOM::Event>, JS::Value> event() const;
[[nodiscard]] JS::NonnullGCPtr<CSS::CSSStyleDeclaration> get_computed_style(DOM::Element&, Optional<String> const& pseudo_element) const;
WebIDL::ExceptionOr<JS::NonnullGCPtr<CSS::MediaQueryList>> match_media(String const& query);
[[nodiscard]] JS::NonnullGCPtr<CSS::Screen> screen();
[[nodiscard]] JS::GCPtr<CSS::VisualViewport> visual_viewport();
i32 inner_width() const;
i32 inner_height() const;
double scroll_x() const;
double scroll_y() const;
void scroll(ScrollToOptions const&);
void scroll(double x, double y);
void scroll_by(ScrollToOptions);
void scroll_by(double x, double y);
i32 screen_x() const;
i32 screen_y() const;
i32 outer_width() const;
i32 outer_height() const;
double device_pixel_ratio() const;
i32 request_animation_frame(WebIDL::CallbackType&);
void cancel_animation_frame(i32 handle);
u32 request_idle_callback(WebIDL::CallbackType&, RequestIdleCallback::IdleRequestOptions const&);
void cancel_idle_callback(u32 handle);
JS::GCPtr<Selection::Selection> get_selection() const;
[[nodiscard]] JS::NonnullGCPtr<HighResolutionTime::Performance> performance();
[[nodiscard]] JS::NonnullGCPtr<Crypto::Crypto> crypto();
[[nodiscard]] JS::NonnullGCPtr<CustomElementRegistry> custom_elements();
HighResolutionTime::DOMHighResTimeStamp get_last_activation_timestamp() const { return m_last_activation_timestamp; }
void set_last_activation_timestamp(HighResolutionTime::DOMHighResTimeStamp timestamp) { m_last_activation_timestamp = timestamp; }
static void set_internals_object_exposed(bool);
[[nodiscard]] OrderedHashMap<String, JS::NonnullGCPtr<Navigable>> document_tree_child_navigable_target_name_property_set();
[[nodiscard]] Vector<DeprecatedString> supported_property_names();
[[nodiscard]] WebIDL::ExceptionOr<JS::Value> named_item_value(FlyString const&);
private:
explicit Window(JS::Realm&);
virtual void visit_edges(Cell::Visitor&) override;
// ^HTML::GlobalEventHandlers
virtual DOM::EventTarget& global_event_handlers_to_event_target(FlyString const&) override { return *this; }
// ^HTML::WindowEventHandlers
virtual DOM::EventTarget& window_event_handlers_to_event_target() override { return *this; }
void invoke_idle_callbacks();
struct [[nodiscard]] NamedObjects {
Vector<JS::NonnullGCPtr<Navigable>> navigables;
Vector<JS::NonnullGCPtr<DOM::Element>> elements;
};
NamedObjects named_objects(StringView name);
WebIDL::ExceptionOr<void> window_post_message_steps(JS::Value, WindowPostMessageOptions const&);
// https://html.spec.whatwg.org/multipage/window-object.html#concept-document-window
JS::GCPtr<DOM::Document> m_associated_document;
JS::GCPtr<DOM::Event> m_current_event;
// https://html.spec.whatwg.org/multipage/webappapis.html#concept-window-import-map
ImportMap m_import_map;
// https://html.spec.whatwg.org/multipage/webappapis.html#import-maps-allowed
bool m_import_maps_allowed { true };
JS::GCPtr<HighResolutionTime::Performance> m_performance;
JS::GCPtr<Crypto::Crypto> m_crypto;
JS::GCPtr<CSS::Screen> m_screen;
JS::GCPtr<Navigator> m_navigator;
JS::GCPtr<Location> m_location;
// https://html.spec.whatwg.org/multipage/nav-history-apis.html#window-navigation-api
JS::GCPtr<Navigation> m_navigation;
// https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements-api
// Each Window object is associated with a unique instance of a CustomElementRegistry object, allocated when the Window object is created.
JS::GCPtr<CustomElementRegistry> m_custom_element_registry;
AnimationFrameCallbackDriver m_animation_frame_callback_driver;
// https://w3c.github.io/requestidlecallback/#dfn-list-of-idle-request-callbacks
Vector<NonnullRefPtr<IdleCallback>> m_idle_request_callbacks;
// https://w3c.github.io/requestidlecallback/#dfn-list-of-runnable-idle-callbacks
Vector<NonnullRefPtr<IdleCallback>> m_runnable_idle_callbacks;
// https://w3c.github.io/requestidlecallback/#dfn-idle-callback-identifier
u32 m_idle_callback_identifier = 0;
// https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-plugin-objects
Vector<JS::NonnullGCPtr<Plugin>> m_pdf_viewer_plugin_objects;
// https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-mime-type-objects
Vector<JS::NonnullGCPtr<MimeType>> m_pdf_viewer_mime_type_objects;
// [[CrossOriginPropertyDescriptorMap]], https://html.spec.whatwg.org/multipage/browsers.html#crossoriginpropertydescriptormap
CrossOriginPropertyDescriptorMap m_cross_origin_property_descriptor_map;
// https://html.spec.whatwg.org/multipage/interaction.html#user-activation-data-model
HighResolutionTime::DOMHighResTimeStamp m_last_activation_timestamp { NumericLimits<double>::max() };
// https://streams.spec.whatwg.org/#count-queuing-strategy-size-function
JS::GCPtr<WebIDL::CallbackType> m_count_queuing_strategy_size_function;
// https://streams.spec.whatwg.org/#byte-length-queuing-strategy-size-function
JS::GCPtr<WebIDL::CallbackType> m_byte_length_queuing_strategy_size_function;
};
void run_animation_frame_callbacks(DOM::Document&, double now);
}
Reference in a new issue View git blame Copy permalink