Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/DOM/Document.h

783 lines
33 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
/*
LibWeb: Implement Document.createAttribute{,NS}()
2023-03-10 14:56:03 +01:00
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
LibWeb/HTML: Port Window.history to IDL
2023-03-05 20:21:35 +00:00
* Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
LibWeb: Port validate_and_extract from DeprecatedFlyString
2023-11-05 12:37:49 +13:00
* Copyright (c) 2023, Shannon Booth <shannon@serenityos.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 18:55:47 +02:00
#pragma once
LibHTML: Add function for invalidating the document layout This allows any external actor to signal that the document layout may be stale. This can be used when loading resources, changing the size or placement of an element, adding/removing nodes, or really any time.
2019-10-06 22:58:18 +11:00
#include <AK/Function.h>
LibWeb: Give each Node a unique ID We maintain a directory of ID -> Node. Nodes add themselves to this directory when they are created, receiving a random ID. When a Node is destroyed, it removes itself from this directory. Anyone can request a Node from the directory by its ID using `Node::from_id()`. We reserve the `0` ID to mean "none". These IDs allow different processes to communicate about a given Node over IPC, for example the DOM Inspector.
2021-08-30 15:52:08 +01:00
#include <AK/HashMap.h>
LibHTML: Refactor to go from DOM -> styled tree -> layout tree. Frame::layout() drives everything now, it takes the DOM contained in the frame and puts it through the tree transformations.
2019-06-29 21:42:07 +02:00
#include <AK/OwnPtr.h>
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
#include <AK/String.h>
LibHTML: Add load(URL) and reload() functions to HtmlView You can now pass a file:/// URL to HtmlView and it will take care of the loading logic for you. Each Document remembers the URL it was loaded from, which allows us to also have reload(). This patch also adds a very simple function for resolving relative URL's into absolute ones.
2019-10-05 10:16:27 +02:00
#include <AK/URL.h>
LibWeb: Add stubs for document.write and document.writeln ACID3 test page throws exception about document.write. Let's at least get rid of it by defining these stubs. I added document.writeln too because it is similar.
2022-02-15 17:36:27 +01:00
#include <AK/Vector.h>
LibHTML: Add a Frame class and use it for document layout width Each HtmlView now has a main_frame(), which represents the main frame of the web page. Frame inherits from TreeNode<Frame>, which will allow us to someday implement a Frame tree (to support the <frame> element.)
2019-10-04 15:50:04 +02:00
#include <AK/WeakPtr.h>
LibGfx: Replace manual forward declarations with <LibGfx/Forward.h>
2020-02-15 00:10:34 +01:00
#include <LibCore/Forward.h>
LibWeb: Parse <script> elements and run any JavaScript found inside This patch begins integrating LibJS into LibWeb. Document holds the JS::Interpreter for now, and it is created on demand when you first call Document::interpreter(). We also add a simple "alert()" function to the global object.
2020-03-14 12:41:51 +01:00
#include <LibJS/Forward.h>
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 16:14:04 +01:00
#include <LibWeb/CSS/CSSStyleSheet.h>
LibWeb: Process style sheets in document order Until now we would simply apply stylesheets in the order they finished loading. This patch adds a StyleSheetList object that hangs off of each Document and contains all the style sheets in document order. There's still a lot of work to do for a proper cascade, but at least this makes us consistently wrong every time. :^)
2020-06-04 16:06:32 +02:00
#include <LibWeb/CSS/StyleSheetList.h>
Browser+LibWeb+WebContent: Track the source of document.cookie requests To implement the HttpOnly attribute, the CookieJar needs to know where a request originated from. Namely, it needs to distinguish between HTTP / non-HTTP (i.e. JavaScript) requests. When the HttpOnly attribute is set, requests from JavaScript are to be blocked.
2021-04-13 17:30:41 -04:00
#include <LibWeb/Cookie/Cookie.h>
LibWeb: Move get_element_by_id() to a NonElementParentNode mixin class This matches the current version of the DOM spec. And since C++ doesn't have mixins this is actually a CRTP class.
2020-03-28 09:12:13 +01:00
#include <LibWeb/DOM/NonElementParentNode.h>
LibWeb: Rename directory LibHTML => LibWeb Let's rename this to LibWeb since it aims to provide more parts of the web platform than just HTML. :^)
2020-03-07 10:32:51 +01:00
#include <LibWeb/DOM/ParentNode.h>
LibWeb: Remove unecessary dependence on Window from DOM and WebIDL These classes only needed Window to get at its realm. Pass a realm directly to construct DOM and WebIDL classes. This change importantly removes the guarantee that a Document will always have a non-null Window object. Only Documents created by a BrowsingContext will have a non-null Window object. Documents created by for example, DocumentFragment, will not have a Window (soon). This incremental commit leaves some workarounds in place to keep other parts of the code building.
2022-09-25 16:15:49 -06:00
#include <LibWeb/HTML/BrowsingContext.h>
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 10:55:47 +02:00
#include <LibWeb/HTML/CrossOrigin/CrossOriginOpenerPolicy.h>
LibWeb: Store HTML document ready state as an enum
2021-09-26 12:08:50 +02:00
#include <LibWeb/HTML/DocumentReadyState.h>
LibWeb: Flesh out prepare_script and execute_script This fills in a bunch of the FIXMEs that was in prepare_script. execute_script is almost finished, it's just missing the module side. As an aside, let's not assert when inserting a script element with innerHTML.
2021-01-28 20:31:20 +00:00
#include <LibWeb/HTML/HTMLScriptElement.h>
LibWeb: Add the History object and stub pushState and replaceState The spec allows us to optionally return from these for any reason. Our reason is that we don't have all the infrastructure in place yet to implement them.
2021-09-11 23:43:34 +01:00
#include <LibWeb/HTML/History.h>
LibWeb: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 18:50:09 +00:00
#include <LibWeb/HTML/LazyLoadingElement.h>
LibWeb: Move Origin into the HTML namespace Origin is defined in the HTML Standard, and therefore belongs into the HTML directory and namespace in LibWeb. https://html.spec.whatwg.org/multipage/origin.html#origin
2022-07-12 20:37:43 +01:00
#include <LibWeb/HTML/Origin.h>
LibWeb: Keep more of the navigation parameters in Document
2022-09-19 17:44:37 +02:00
#include <LibWeb/HTML/SandboxingFlagSet.h>
LibWeb: Introduce the Environment Settings Object The environment settings object is effectively the context a piece of script is running under, for example, it contains the origin, responsible document, realm, global object and event loop for the current context. This effectively replaces ScriptExecutionContext, but it cannot be removed in this commit as EventTarget still depends on it. https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
2021-10-14 16:12:53 +01:00
#include <LibWeb/HTML/Scripting/Environments.h>
LibWeb: Forbid sharing image requests across documents This change addresses the bug where images unable to load when the reload button in the UI is clicked repeatedly. Before this fix, it was possible to use SharedImageRequests across multiple documents. However, when the document that initiated the request is gone, tasks scheduled on the event loop remain in the fetching state because the originating document is no longer active. Furthermore, another reason to prohibit the sharing of image requests across documents is that the "Origin" header in an image request is dependent on the document.
2023-10-17 16:52:16 +02:00
#include <LibWeb/HTML/SharedImageRequest.h>
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
#include <LibWeb/HTML/VisibilityState.h>
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
#include <LibWeb/WebIDL/ExceptionOr.h>
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 18:55:47 +02:00
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
namespace Web::DOM {
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 21:17:17 +01:00
enum class QuirksMode {
No,
Limited,
Yes
};
LibWeb: Add load/unload timing structures to Document We don't populate these with information just yet, but we will soon!
2022-09-21 00:03:53 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#document-load-timing-info
struct DocumentLoadTimingInfo {
// https://html.spec.whatwg.org/multipage/dom.html#navigation-start-time
double navigation_start_time { 0 };
// https://html.spec.whatwg.org/multipage/dom.html#dom-interactive-time
double dom_interactive_time { 0 };
// https://html.spec.whatwg.org/multipage/dom.html#dom-content-loaded-event-start-time
double dom_content_loaded_event_start_time { 0 };
// https://html.spec.whatwg.org/multipage/dom.html#dom-content-loaded-event-end-time
double dom_content_loaded_event_end_time { 0 };
// https://html.spec.whatwg.org/multipage/dom.html#dom-complete-time
double dom_complete_time { 0 };
// https://html.spec.whatwg.org/multipage/dom.html#load-event-start-time
double load_event_start_time { 0 };
// https://html.spec.whatwg.org/multipage/dom.html#load-event-end-time
double load_event_end_time { 0 };
};
// https://html.spec.whatwg.org/multipage/dom.html#document-unload-timing-info
struct DocumentUnloadTimingInfo {
// https://html.spec.whatwg.org/multipage/dom.html#unload-event-start-time
double unload_event_start_time { 0 };
// https://html.spec.whatwg.org/multipage/dom.html#unload-event-end-time
double unload_event_end_time { 0 };
};
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
struct ElementCreationOptions {
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
Optional<String> is;
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
};
LibWeb+LibWebView+WebContent: Add APIs to manage an autoplay allowlist The spec defines a Permissions Policy to control some browser behaviors on a per-origin basis. Management of these permissions live in their own spec: https://w3c.github.io/webappsec-permissions-policy/ This implements a somewhat ad-hoc Permissions Policy for autoplaying media elements. We will need to implement the entire policy spec for this to be more general.
2023-04-17 13:21:19 -04:00
enum class PolicyControlledFeature {
Autoplay,
};
LibWeb: Move get_element_by_id() to a NonElementParentNode mixin class This matches the current version of the DOM spec. And since C++ doesn't have mixins this is actually a CRTP class.
2020-03-28 09:12:13 +01:00
class Document
: public ParentNode
LibWeb: Add Bindings::ScriptExecutionContext This will be inherited by documents and workers, to provide a common abstraction for script execution. (We don't have workers yet, but we might as well make this little space for them now to simplify things down the road.)
2020-09-20 19:22:44 +02:00
, public NonElementParentNode<Document>
LibWeb: Rewrite EventTarget to more closely match the spec This isn't perfect (especially the global object situation in activate_event_handler), but I believe it's in a much more complete state now :^) This fixes the issue of crashing in prepare_for_ordinary_call with the `i < m_size` crash, as it now uses the IDL callback functions which requires the Environment Settings Object. The environment settings object for the callback is fetched at the time the callback is created, for example, WrapperGenerator gets the incumbent settings object for the callback at the time of wrapping. This allows us to remove passing in ScriptExecutionContext into EventTarget's constructor. With this, we can now drop ScriptExecutionContext.
2021-10-14 18:03:08 +01:00
, public HTML::GlobalEventHandlers {
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.
2022-08-28 13:42:07 +02:00
WEB_PLATFORM_OBJECT(Document, ParentNode);
LibWeb: Put most LibWeb GC objects in type-specific heap blocks With this change, we now have ~1200 CellAllocators across both LibJS and LibWeb in a normal WebContent instance. This gives us a minimum heap size of 4.7 MiB in the scenario where we only have one cell allocated per type. Of course, in practice there will be many more of each type, so the effective overhead is quite a bit smaller than that in practice. I left a few types unconverted to this mechanism because I got tired of doing this. :^)
2023-11-19 19:47:52 +01:00
JS_DECLARE_ALLOCATOR(Document);
LibWeb: Start implementing basic JavaScript DOM bindings This patch introduces the Wrapper and Wrappable classes. Node now inherits from Wrappable, and can be wrapped in a GC-allocated Bindings::NodeWrapper object. The only property we expose right now is the very simple nodeName property. When a Document's JS::Interpreter is first instantiated, we add a "document" property with a DocumentWrapper object to the global object. This is pretty cool! :^)
2020-03-14 13:15:11 +01:00
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.
2022-08-28 13:42:07 +02:00
public:
LibWeb: Add the type field to DOM::Document This patch adds the document type concept to documents and sets it in various places.
2022-07-03 21:44:00 +02:00
enum class Type {
XML,
HTML
};
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
static WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> create_and_initialize(Type, String content_type, HTML::NavigationParams&);
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
LibJS: Make Heap::allocate<T>() infallible Stop worrying about tiny OOMs. Work towards #20449. While going through these, I also changed the function signature in many places where returning ThrowCompletionOr<T> is no longer necessary.
2023-08-13 13:05:26 +02:00
[[nodiscard]] static JS::NonnullGCPtr<Document> create(JS::Realm&, AK::URL const& url = "about:blank"sv);
LibWeb: Make factory methods of DOM::Document fallible
2023-02-14 21:49:02 +01:00
static WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> construct_impl(JS::Realm&);
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 18:55:47 +02:00
virtual ~Document() override;
LibWeb: Implement Document::populate_with_html_head_and_body()
2023-12-18 14:00:30 +00:00
WebIDL::ExceptionOr<void> populate_with_html_head_and_body();
LibWeb/HTML: Port Window.getSelection() to IDL
2023-03-06 22:34:48 +00:00
JS::GCPtr<Selection::Selection> get_selection() const;
LibWeb: Make Window.getSelection() forward to Document.getSelection() (And have document create the Selection object on demand.)
2022-10-10 21:23:03 +02:00
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String cookie(Cookie::Source = Cookie::Source::NonHttp);
LibWeb: Make Document::set_cookie take a StringView Enabled by also making the same change to ParsedCookie::parse_cookie :^)
2023-09-12 22:11:24 +12:00
void set_cookie(StringView, Cookie::Source = Cookie::Source::NonHttp);
LibWeb: Stub out Document.cookie We don't get/set anything, but at least scripts that access document cookies can now progress further. :^)
2021-03-14 16:35:28 +01:00
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String referrer() const;
void set_referrer(String);
LibWeb: Add naive support for the Document.referrer attribute It always returns the empty string for now.
2021-09-11 12:29:06 +02:00
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
void set_url(const AK::URL& url) { m_url = url; }
AK::URL url() const { return m_url; }
LibWeb: Add support for the <base> element changing the base URL Used by Google seemingly almost all around account sign in and management. The modern sign in page has this near the beginning: ```html <base href="https://accounts.google.com"> ``` All of the XHRs performed by sign in are relative URLs to this base URL. Previously we ignored this and did it relative to the current URL, causing the XHRs to 404 and sign in to fall apart. I presume they do this because you can access the sign in page from multiple endpoints, such as `/ServiceLogin` and `/o/oauth2/auth/identifier`
2022-06-19 16:02:48 +01:00
AK::URL fallback_base_url() const;
AK::URL base_url() const;
LibWeb: Cache the first <base href> (in tree order) in Document When parsing relative URLs, we have to check the first <base href> in tree order (if one is available). This was getting *very* costly on large DOMs with many relative urls. This patch avoids all that repeated traversal by letting Document cache the first <base href> and invalidating the cache whenever a <base> element is added/removed/edited in the DOM. The browser was stuck doing this for a *very* long time when loading the ECMA-262 spec, and this removes that problem entirely.
2022-11-04 20:56:30 +01:00
void update_base_element(Badge<HTML::HTMLBaseElement>);
LibWeb: Fix a few const-ness issues
2023-02-25 10:44:51 -07:00
JS::GCPtr<HTML::HTMLBaseElement const> first_base_element_with_href_in_tree_order() const;
LibHTML: Add load(URL) and reload() functions to HtmlView You can now pass a file:/// URL to HtmlView and it will take care of the loading logic for you. Each Document remembers the URL it was loaded from, which allows us to also have reload(). This patch also adds a very simple function for resolving relative URL's into absolute ones.
2019-10-05 10:16:27 +02:00
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String url_string() const { return MUST(m_url.to_string()); }
String document_uri() const { return url_string(); }
LibWeb: Bring Document closer to spec
2022-04-12 13:19:35 -03:00
LibWeb: Move Origin into the HTML namespace Origin is defined in the HTML Standard, and therefore belongs into the HTML directory and namespace in LibWeb. https://html.spec.whatwg.org/multipage/origin.html#origin
2022-07-12 20:37:43 +01:00
HTML::Origin origin() const;
void set_origin(HTML::Origin const& origin);
LibWeb: Add Origin concept (protocol, host, port tuple) Every Document now has an Origin, found via Document::origin(). It's based on the URL of the document. This will be used to implement things like the same-origin policy.
2020-04-07 22:56:13 +02:00
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 10:55:47 +02:00
HTML::CrossOriginOpenerPolicy const& cross_origin_opener_policy() const { return m_cross_origin_opener_policy; }
void set_cross_origin_opener_policy(HTML::CrossOriginOpenerPolicy policy) { m_cross_origin_opener_policy = move(policy); }
LibWeb: Change Document::parse_url to accept a StringView There's no need for this to require a DeprecatedString - the method it wraps around already only expects a StringView. This allows passing a String instance without any conversion.
2023-05-12 14:09:05 -04:00
AK::URL parse_url(StringView) const;
LibHTML: Add load(URL) and reload() functions to HtmlView You can now pass a file:/// URL to HtmlView and it will take care of the loading logic for you. Each Document remembers the URL it was loaded from, which allows us to also have reload(). This patch also adds a very simple function for resolving relative URL's into absolute ones.
2019-10-05 10:16:27 +02:00
LibWeb: Rename CSS::StyleResolver => StyleComputer Resolved style is a spec concept that refers to the weird mix of computed style and used style reflected by getComputedStyle(). The purpose of this class is to produce the *computed* style for a given element, so let's call it StyleComputer.
2021-09-24 13:49:57 +02:00
CSS::StyleComputer& style_computer() { return *m_style_computer; }
const CSS::StyleComputer& style_computer() const { return *m_style_computer; }
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
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.
2022-08-28 13:42:07 +02:00
CSS::StyleSheetList& style_sheets();
CSS::StyleSheetList const& style_sheets() const;
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
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.
2022-08-28 13:42:07 +02:00
CSS::StyleSheetList* style_sheets_for_bindings() { return &style_sheets(); }
LibWeb: Start exposing CSS style sheets to JavaScript :^) This patch adds bindings for the following objects: - StyleSheet - StyleSheetList - CSSStyleSheet You can get to a document's style sheets via Document.styleSheets and iterate through them using StyleSheetList's item() and length(). That's it in terms of functionality at this point, but still neat. :^)
2021-03-08 11:22:18 +01:00
LibWeb: Port Node interface from DeprecatedString to String Which is fortunately quite straight forward :^)
2023-09-17 10:51:43 +12:00
virtual FlyString node_name() const override { return "#document"_fly_string; }
LibHTML: Add virtual Node::tag_name() This is analogous to the DOM's Node.tagName and makes it easy to ask "hey, what kinda thing is this Node?"
2019-09-28 22:59:16 +02:00
LibHTML: Implement basic :hover pseudo-class support This is currently very aggressive. Whenever the Document's hovered node changes, we invalidate all style and do a full relayout. It does look cool though. So cool that I'm adding it to the default stylesheet. :^)
2019-10-14 17:54:17 +02:00
void set_hovered_node(Node*);
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.
2022-08-28 13:42:07 +02:00
Node* hovered_node() { return m_hovered_node.ptr(); }
Node const* hovered_node() const { return m_hovered_node.ptr(); }
LibHTML: Have Document track its hovered Node This gets set from HtmlView::mousemove_event() at the moment.
2019-09-29 11:50:35 +02:00
LibWeb: Wrap PseudoElements stored in SimpleSelector in a class No functional impact intended. This is just a more complicated way of writing what we have now. The goal of this commit is so that we are able to store the 'name' of a pseudo element for use in serializing 'unknown -webkit- pseudo-elements', see: https://www.w3.org/TR/selectors-4/#compat This is quite awkward, as in pretty much all cases just the selector type enum is enough, but we will need to cache the name for serializing these unknown selectors. I can't figure out any reason why we would need this name anywhere else in the engine, so pretty much everywhere is still just passing around this raw enum. But this change will allow us to easily store the name inside of this new struct for when it is needed for serialization, once those webkit unknown elements are supported by our engine.
2023-12-10 21:00:03 +13:00
void set_inspected_node(Node*, Optional<CSS::Selector::PseudoElement::Type>);
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.
2022-08-28 13:42:07 +02:00
Node* inspected_node() { return m_inspected_node.ptr(); }
Node const* inspected_node() const { return m_inspected_node.ptr(); }
LibWeb: Make pseudo-elements inspectable This makes it possible to set a pseudo-element as the inspected node using Document::set_inspected_node(), Document then provides inspected_layout_node() for the painting related functions.
2023-06-02 22:50:11 +02:00
Layout::Node* inspected_layout_node();
Layout::Node const* inspected_layout_node() const { return const_cast<Document*>(this)->inspected_layout_node(); }
LibHTML: Paint a magenta rectangle around the currently inspected node Document now tracks one "inspected" node, set by set_inspected_node() which is called by Browser's DOM inspector view on_selection callback.
2019-11-09 11:58:50 +01:00
LibWeb: Support assigning to document.body when it is null
2021-02-22 14:00:47 +01:00
Element* document_element();
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Element const* document_element() const;
LibWeb: Support assigning to document.body when it is null
2021-02-22 14:00:47 +01:00
LibWeb: Add non-const variants of Document::{html_element,body,head}()
2021-05-07 00:53:22 +01:00
HTML::HTMLHtmlElement* html_element();
HTML::HTMLHeadElement* head();
LibWeb: Add an accessor for the document's title element
2023-06-07 15:13:42 -04:00
JS::GCPtr<HTML::HTMLTitleElement> title_element();
LibWeb: Add non-const variants of Document::{html_element,body,head}()
2021-05-07 00:53:22 +01:00
HTML::HTMLElement* body();
LibWeb: Convert a couple west-const formattings to east-const
2023-06-07 14:16:12 -04:00
HTML::HTMLHtmlElement const* html_element() const
LibWeb: Add non-const variants of Document::{html_element,body,head}()
2021-05-07 00:53:22 +01:00
{
return const_cast<Document*>(this)->html_element();
}
LibWeb: Convert a couple west-const formattings to east-const
2023-06-07 14:16:12 -04:00
HTML::HTMLHeadElement const* head() const
LibWeb: Add non-const variants of Document::{html_element,body,head}()
2021-05-07 00:53:22 +01:00
{
return const_cast<Document*>(this)->head();
}
LibWeb: Add an accessor for the document's title element
2023-06-07 15:13:42 -04:00
JS::GCPtr<HTML::HTMLTitleElement const> title_element() const
{
return const_cast<Document*>(this)->title_element();
}
LibWeb: Convert a couple west-const formattings to east-const
2023-06-07 14:16:12 -04:00
HTML::HTMLElement const* body() const
LibWeb: Add non-const variants of Document::{html_element,body,head}()
2021-05-07 00:53:22 +01:00
{
return const_cast<Document*>(this)->body();
}
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
WebIDL::ExceptionOr<void> set_body(HTML::HTMLElement* new_body);
LibHTML: Add a way to get a Document's title You can now query Document::title() to get a String containing whatever is inside the document's <title> tag. In support of this, this patch adds the <html>, <head> and <title> elements.
2019-09-29 16:24:57 +02:00
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String title() const;
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
WebIDL::ExceptionOr<void> set_title(String const&);
LibHTML: Add a way to get a Document's title You can now query Document::title() to get a String containing whatever is inside the document's <title> tag. In support of this, this patch adds the <html>, <head> and <title> elements.
2019-09-29 16:24:57 +02:00
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 15:01:28 +01:00
HTML::BrowsingContext* browsing_context() { return m_browsing_context.ptr(); }
HTML::BrowsingContext const* browsing_context() const { return m_browsing_context.ptr(); }
LibHTML: Add a Frame class and use it for document layout width Each HtmlView now has a main_frame(), which represents the main frame of the web page. Frame inherits from TreeNode<Frame>, which will allow us to someday implement a Frame tree (to support the <frame> element.)
2019-10-04 15:50:04 +02:00
LibWeb: Implement Document/BrowsingContext hookup according to spec We now implement the browsing context's "set active document" algorithm from the spec, as well as the "discard" algorithm for browsing contexts and documents.
2022-09-20 21:44:42 +02:00
void set_browsing_context(HTML::BrowsingContext*);
LibWeb: Make Document::page() return a Page& Now that Document always has a Page, and always keeps it alive, we can make this return a Page&, exposing various unnecessary null checks.
2023-12-15 15:41:28 +01:00
Page& page();
Page const& page() const;
LibWeb: Make Frame point weakly to Page This patch makes Page weakable and allows page-less frames to exist. Page is single-owner, and Frame is multiple-owner, so it's not sound for Frame to assume its containing Page will stick around for its own entire lifetime. Fixes #3976.
2020-11-12 18:23:05 +01:00
LibWeb+WebContent: Make document background and Viewport transparent This means iframes are transparent by default (as in firefox/chrome). Painting the outermost canvas background is moved to the PageHost.
2023-04-24 22:38:50 +02:00
Color background_color() const;
LibWeb: Store background layers in ComputedValues Instead of storing these as individual `background-foo` properties, we combine them together into layers, since that is how they will be painted. It also makes it more convenient to pass them around.
2021-11-12 12:11:01 +00:00
Vector<CSS::BackgroundLayerData> const* background_layers() const;
LibHTML: Add support for <body bgcolor="#rrggbb" text="#rrggbb"> This patch implements basic support for presentational hints, which are old-school HTML attributes that affect style. You add support for a presentational hint attribute by overriding Element::apply_presentational_hints(StyleProperties&) and setting all of the corresponding CSS properties as appropriate. To make the background color fill the entire document, not just the bounds of the <body> element's LayoutNode, we special-case it in the HtmlView::paint_event() code for now. I'm not entirely sure what the nicest solution would be, but I'm sure we'll discover it eventually.
2019-10-04 21:05:52 +02:00
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 20:33:15 +01:00
Color link_color() const;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 10:11:54 +02:00
void set_link_color(Color);
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 20:33:15 +01:00
Color active_link_color() const;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 10:11:54 +02:00
void set_active_link_color(Color);
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 20:33:15 +01:00
Color visited_link_color() const;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 10:11:54 +02:00
void set_visited_link_color(Color);
LibHTML: Add Document::force_layout() ..for when you really need a layout to happen right now. Also, automatically repaint the layout root after layout.
2019-10-28 20:51:45 +01:00
void force_layout();
LibHTML: Move layout root from HtmlView to Document The layout root is now kept alive via Document::m_layout_root. This will allow us to do more layout-related things inside the inner layer of LibHTML without reaching out to the HtmlView. I'd like to keep HtmlView at a slightly higher level, to prevent it from getting too complex. This patch also fixes accidental disconnection of the layout tree from the DOM after doing a layout tree rebuild. ~LayoutNode() now only unsets the DOM node's layout_node() if it's itself.
2019-10-13 12:34:25 +02:00
LibHTML: Rename Document's invalidate_{style,layout}() to update_foo()
2019-10-14 17:56:19 +02:00
void update_style();
void update_layout();
LibHTML: Add function for invalidating the document layout This allows any external actor to signal that the document layout may be stale. This can be used when loading resources, changing the size or placement of an element, adding/removing nodes, or really any time.
2019-10-06 22:58:18 +11:00
LibWeb: Make CSS layout lazier Instead of doing layout synchronously whenever something changes, we now use a basic event loop timer to defer and coalesce relayouts. If you did something that requires a relayout of the page, make sure to call Document::set_needs_layout() and it will get coalesced with all the other layout updates. There's lots of room for improvement here, but this already makes many web pages significantly snappier. :^) Also, note that this exposes a number of layout bugs where we have been relying on multiple relayouts to calculate the correct dimensions for things. Now that we only do a single layout in many cases, these kind of problems are much more noticeable. That should also make them easier to figure out and fix. :^)
2021-10-05 22:30:53 +02:00
void set_needs_layout();
LibWeb: Always relayout document on element style change Let's get this right before trying to make it fast. This patch removes the code that tried to do less work when an element's style changes, and instead simply invalidates the entire document. Note that invalidations are still coalesced, and will not be synchronized until update_style() and/or update_layout() is used.
2022-03-09 17:57:45 +01:00
void invalidate_layout();
LibWeb: Only invalidate stacking context tree for opacity/z-index change I came across some websites that change an elements CSS "opacity" in their :hover selectors. That caused us to relayout on hover, which we'd like to avoid. With this patch, we now check if a property only affects the stacking context tree, and if nothing layout-affecting has changed, we only invalidate the stacking context tree, causing it to be rebuilt on next paint or hit test. This makes :hover { opacity: ... } rules much faster. :^)
2022-03-21 10:58:51 +01:00
void invalidate_stacking_context_tree();
LibWeb: Always relayout document on element style change Let's get this right before trying to make it fast. This patch removes the code that tried to do less work when an element's style changes, and instead simply invalidates the entire document. Note that invalidations are still coalesced, and will not be synchronized until update_style() and/or update_layout() is used.
2022-03-09 17:57:45 +01:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
virtual bool is_child_allowed(Node const&) const override;
LibHTML: Add Comment and CharacterData nodes and improve HTML parsing This patch adds the CharacterData subclass of Node, which is now the parent class of Text and a new Comment class. A Comment node is one of these in HTML: <!--hello friends--> Since these occur somewhat frequently on the web, we need to be able to parse them. This patch also adds a child rejection mechanism to the DOM tree. Nodes can now override is_child_allowed(Node) and return false if they don't want a particular Node to become a child of theirs. This is used to prevent Document from taking on unwanted children.
2019-10-12 23:26:47 +02:00
LibWeb: Rename Layout::InitialContainingBlock to Layout::Viewport The name "initial containing block" was wrong for this, as it doesn't correspond to the HTML element, and that's specifically what it's supposed to do! :^)
2023-02-25 11:04:29 +01:00
Layout::Viewport const* layout_node() const;
Layout::Viewport* layout_node();
LibHTML: Move layout root from HtmlView to Document The layout root is now kept alive via Document::m_layout_root. This will allow us to do more layout-related things inside the inner layer of LibHTML without reaching out to the HtmlView. I'd like to keep HtmlView at a slightly higher level, to prevent it from getting too complex. This patch also fixes accidental disconnection of the layout tree from the DOM after doing a layout tree rebuild. ~LayoutNode() now only unsets the DOM node's layout_node() if it's itself.
2019-10-13 12:34:25 +02:00
LibWeb: Make Document::paintable() return a ViewportPaintable
2023-08-19 09:29:04 +02:00
Painting::ViewportPaintable const* paintable() const;
Painting::ViewportPaintable* paintable();
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 18:57:02 +02:00
void schedule_style_update();
LibWeb: Make CSS layout lazier Instead of doing layout synchronously whenever something changes, we now use a basic event loop timer to defer and coalesce relayouts. If you did something that requires a relayout of the page, make sure to call Document::set_needs_layout() and it will get coalesced with all the other layout updates. There's lots of room for improvement here, but this already makes many web pages significantly snappier. :^) Also, note that this exposes a number of layout bugs where we have been relying on multiple relayouts to calculate the correct dimensions for things. Now that we only do a single layout in many cases, these kind of problems are much more noticeable. That should also make them easier to figure out and fix. :^)
2021-10-05 22:30:53 +02:00
void schedule_layout_update();
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 18:57:02 +02:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
JS::NonnullGCPtr<HTMLCollection> get_elements_by_name(String const&);
LibWeb: Take a StringView in Document::get_elements_by_class_name We only ever use the view of the DeprecatedFlyString anyway, so let's just use a StringView.
2023-09-12 22:34:25 +12:00
JS::NonnullGCPtr<HTMLCollection> get_elements_by_class_name(StringView);
LibWeb: Make HTMLCollection and subclasses GC-allocated
2022-09-01 20:50:16 +02:00
JS::NonnullGCPtr<HTMLCollection> applets();
JS::NonnullGCPtr<HTMLCollection> anchors();
JS::NonnullGCPtr<HTMLCollection> images();
JS::NonnullGCPtr<HTMLCollection> embeds();
JS::NonnullGCPtr<HTMLCollection> plugins();
JS::NonnullGCPtr<HTMLCollection> links();
JS::NonnullGCPtr<HTMLCollection> forms();
JS::NonnullGCPtr<HTMLCollection> scripts();
LibWeb: Implement basic support for Document.all The finer details are missing here, but the basic API is up.
2022-09-18 02:17:11 +02:00
JS::NonnullGCPtr<HTMLCollection> all();
LibWeb: Implement document.applets This is a legacy interface that returns an always-empty HTMLCollection.
2021-04-22 22:11:42 +02:00
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String const& source() const { return m_source; }
void set_source(String source) { m_source = move(source); }
LibHTML: Store the HTML parser input along with the created Document This will allow us to "view source" later on, long after parsing has finished and turned it into a DOM.
2019-11-25 00:27:41 +01:00
LibWeb: Implement snapshotting source snapshot params per the spec
2023-08-25 20:34:50 -06:00
HTML::EnvironmentSettingsObject& relevant_settings_object() const;
LibWeb: Parse <script> elements and run any JavaScript found inside This patch begins integrating LibJS into LibWeb. Document holds the JS::Interpreter for now, and it is created on demand when you first call Document::interpreter(). We also add a simple "alert()" function to the global object.
2020-03-14 12:41:51 +01:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element(String const& local_name, Variant<String, ElementCreationOptions> const& options);
WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element_ns(Optional<String> const& namespace_, String const& qualified_name, Variant<String, ElementCreationOptions> const& options);
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.
2022-08-28 13:42:07 +02:00
JS::NonnullGCPtr<DocumentFragment> create_document_fragment();
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
JS::NonnullGCPtr<Text> create_text_node(String const& data);
JS::NonnullGCPtr<Comment> create_comment(String const& data);
WebIDL::ExceptionOr<JS::NonnullGCPtr<ProcessingInstruction>> create_processing_instruction(String const& target, String const& data);
LibWeb: Add Document.createProcessingInstruction() These nodes don't really do anything interesting yet, but let's allow creating them. :^)
2022-12-13 13:24:56 +01:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> create_attribute(String const& local_name);
WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> create_attribute_ns(Optional<String> const& namespace_, String const& qualified_name);
LibWeb: Implement Document.createAttribute{,NS}()
2023-03-10 14:56:03 +01:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
WebIDL::ExceptionOr<JS::NonnullGCPtr<Event>> create_event(StringView interface);
LibWeb: Make AbstractRange and subclasses GC-allocated
2022-08-09 01:06:47 +02:00
JS::NonnullGCPtr<Range> create_range();
LibWeb: Add Document create_element() and create_text_node() helpers
2020-05-10 20:43:54 +02:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
void set_pending_parsing_blocking_script(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement*);
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.
2022-08-28 13:42:07 +02:00
HTML::HTMLScriptElement* pending_parsing_blocking_script() { return m_pending_parsing_blocking_script.ptr(); }
JS::NonnullGCPtr<HTML::HTMLScriptElement> take_pending_parsing_blocking_script(Badge<HTML::HTMLParser>);
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
void add_script_to_execute_when_parsing_has_finished(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
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.
2022-08-28 13:42:07 +02:00
Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_when_parsing_has_finished(Badge<HTML::HTMLParser>);
LibWeb: Do not use JS::Handle for "scripts to execute" in DOM::Document Using JS::Handle in members of GC-allocated object almost always leaks. Instead we should visit these members in visit_edges().
2023-09-27 17:27:47 +02:00
Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>>& scripts_to_execute_when_parsing_has_finished() { return m_scripts_to_execute_when_parsing_has_finished; }
LibWeb: Handle two kinds of deferred script executions This patch adds two script lists to Document: - Scripts to execute when parsing has finished - Scripts to execute as soon as possible Since we don't actually load scripts asynchronously yet (we just do a synchronous load when parsing the <script> element for simplicity), these are already loaded by the time we get to "The end" of parsing.
2020-05-30 12:26:15 +02:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
void add_script_to_execute_as_soon_as_possible(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
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.
2022-08-28 13:42:07 +02:00
Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_as_soon_as_possible(Badge<HTML::HTMLParser>);
LibWeb: Do not use JS::Handle for "scripts to execute" in DOM::Document Using JS::Handle in members of GC-allocated object almost always leaks. Instead we should visit these members in visit_edges().
2023-09-27 17:27:47 +02:00
Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>>& scripts_to_execute_as_soon_as_possible() { return m_scripts_to_execute_as_soon_as_possible; }
LibWeb: Handle two kinds of deferred script executions This patch adds two script lists to Document: - Scripts to execute when parsing has finished - Scripts to execute as soon as possible Since we don't actually load scripts asynchronously yet (we just do a synchronous load when parsing the <script> element for simplicity), these are already loaded by the time we get to "The end" of parsing.
2020-05-30 12:26:15 +02:00
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 17:36:47 +02:00
void add_script_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLParser>);
LibWeb: Do not use JS::Handle for "scripts to execute" in DOM::Document Using JS::Handle in members of GC-allocated object almost always leaks. Instead we should visit these members in visit_edges().
2023-09-27 17:27:47 +02:00
Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>>& scripts_to_execute_in_order_as_soon_as_possible() { return m_scripts_to_execute_in_order_as_soon_as_possible; }
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 17:36:47 +02:00
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 21:17:17 +01:00
QuirksMode mode() const { return m_quirks_mode; }
bool in_quirks_mode() const { return m_quirks_mode == QuirksMode::Yes; }
void set_quirks_mode(QuirksMode mode) { m_quirks_mode = mode; }
LibWeb: Add a "quirks mode" flag to Document This doesn't do anything yet, but it will sooner or later. :^)
2020-05-28 00:20:36 +02:00
LibWeb: Add the type field to DOM::Document This patch adds the document type concept to documents and sets it in various places.
2022-07-03 21:44:00 +02:00
Type document_type() const { return m_type; }
void set_document_type(Type type) { m_type = type; }
LibWeb: Fully implement the fragment serializing algorithm Rather than assuming the node's node document is an HTML document, handle XML documents as well.
2022-11-02 19:14:27 -04:00
// https://dom.spec.whatwg.org/#html-document
bool is_html_document() const { return m_type == Type::HTML; }
LibWeb: Add the type field to DOM::Document This patch adds the document type concept to documents and sets it in various places.
2022-07-03 21:44:00 +02:00
// https://dom.spec.whatwg.org/#xml-document
bool is_xml_document() const { return m_type == Type::XML; }
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> import_node(JS::NonnullGCPtr<Node> node, bool deep);
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
void adopt_node(Node&);
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> adopt_node_binding(JS::NonnullGCPtr<Node>);
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
DocumentType const* doctype() const;
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String const& compat_mode() const;
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 21:17:17 +01:00
LibWeb: Only allow editing of elements with contenteditable="true" We now respect the contenteditable HTML attribute and only let you edit content inside explicitly editable elements.
2020-08-02 16:05:59 +02:00
void set_editable(bool editable) { m_editable = editable; }
virtual bool is_editable() const final;
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.
2022-08-28 13:42:07 +02:00
Element* focused_element() { return m_focused_element.ptr(); }
Element const* focused_element() const { return m_focused_element.ptr(); }
LibWeb: Allow focusing individual (focusable) elements with Tab key You can now cycle through focusable elements (currently only hyperlinks are focusable) with the Tab key. The focus outline is rendered in a new FocusOutline paint phase.
2020-08-14 19:40:37 +02:00
void set_focused_element(Element*);
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.
2022-08-28 13:42:07 +02:00
Element const* active_element() const { return m_active_element.ptr(); }
LibWeb: Support :active pseudo-class for hyperlinks, :focus possibly Adds support for the :active pseudo-class for hyperlinks (<a> tags only). Also, since it was very similar to :focus and an element having a focused state was already implemented, I went ahead and implemented that pseudo-class too, although I cannot come up with a working example to validate it.
2021-06-18 16:42:34 -06:00
void set_active_element(Element*);
LibWeb: Give Document a "target element" The target element is the one matching the URL fragment. We don't yet set it to anything.
2023-08-11 20:14:44 +01:00
Element const* target_element() const { return m_target_element.ptr(); }
void set_target_element(Element*);
LibWeb: Implement and use "scroll to the fragment" algorithm This will eventually be used by Navigable but for now, it's just when traversing the history.
2023-08-11 20:26:02 +01:00
void scroll_to_the_fragment();
void scroll_to_the_beginning_of_the_document();
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
bool created_for_appropriate_template_contents() const { return m_created_for_appropriate_template_contents; }
LibWeb: Update "appropriate template contents owner document" AO This was moved from HTMLTemplateElement to Document at some point, so let's match the spec and move it here too.
2022-10-29 13:06:24 +02:00
JS::NonnullGCPtr<Document> appropriate_template_contents_owner_document();
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
LibWeb: Make Document::{visibility,read}_state return a StringView Also using the visibility state enum to change strcmp to a simple enum state check :^)
2023-09-12 23:17:07 +12:00
StringView ready_state() const;
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
HTML::DocumentReadyState readiness() const { return m_readiness; }
LibWeb: Implement "update the current document readiness" from spec The only difference from what we were already doing is that setting the same ready state twice no longer fires a "readystatechange" event. I don't think that could happen in practice though.
2021-09-26 12:22:16 +02:00
void update_readiness(HTML::DocumentReadyState);
LibWeb: Implement document ready state
2020-08-31 13:56:16 +01:00
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.
2022-08-28 13:42:07 +02:00
HTML::Window& window() const { return const_cast<HTML::Window&>(*m_window); }
LibWeb: Dispatch "load" on document and window These happen right after "DOMContentLoaded" for now, which is incorrect since they should really wait until subresources have loaded. However, this makes a bunch of things work already so let's do it.
2020-10-18 13:45:28 +02:00
LibWeb: Implement "create a new browsing context and document" Co-authored-by: Andreas Kling <kling@serenityos.org>
2023-04-23 19:31:46 +03:00
void set_window(HTML::Window&);
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 10:55:47 +02:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
WebIDL::ExceptionOr<void> write(Vector<String> const& strings);
WebIDL::ExceptionOr<void> writeln(Vector<String> const& strings);
LibWeb: Add basic support for dynamic markup insertion This implements basic support for dynamic markup insertion, adding * Document::open() * Document::write(Vector<String> const&) * Document::writeln(Vector<String> const&) * Document::close() The HTMLParser is modified to make it possible to create a script-created parser which initially only contains a HTMLTokenizer without any data. Aditionally the HTMLParser::run method gains an overload which does not modify the Document and does not run HTMLParser::the_end() so that we can reenter the parser at a later time. Furthermore all FIXMEs that consern the insertion point are implemented wich is defined in the HTMLTokenizer. Additionally the following member-variables of the HTMLParser are now exposed by getter funcions: * m_tokenizer * m_aborted * m_script_nesting_level The HTMLTokenizer is modified so that it contains an insertion point which keeps track of where the next input from the Document::write functions will be inserted. The insertion point is implemented as the charakter offset into m_decoded_input and a boolean describing if the insertion point is defined. Functions to update, check and {re}store the insertion point are also added. The function HTMLTokenizer::insert_eof is added to tell a script-created parser that document::close was called and HTMLParser::the_end() should be called. Lastly an explicit default constructor is added to HTMLTokenizer to create a empty HTMLTokenizer into which data can be inserted.
2022-02-19 15:58:21 +01:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
WebIDL::ExceptionOr<Document*> open(Optional<String> const& = {}, Optional<String> const& = {});
LibWeb: Make Document::open functions take a StringView One of these functions doesn't make any use of the arguments at all, and the other defers to an open helper which already takes a StringView.
2023-09-12 22:29:43 +12:00
WebIDL::ExceptionOr<JS::GCPtr<HTML::WindowProxy>> open(StringView url, StringView name, StringView features);
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 17:03:42 +01:00
WebIDL::ExceptionOr<void> close();
LibWeb: Add stubs for document.write and document.writeln ACID3 test page throws exception about document.write. Let's at least get rid of it by defining these stubs. I added document.writeln too because it is similar.
2022-02-15 17:36:27 +01:00
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.
2022-08-28 13:42:07 +02:00
HTML::Window* default_view() { return m_window.ptr(); }
LibWeb: Start implementing the Element scroll attributes These are required for hit testing the document in Google Docs. If they aren't defined, the Google Docs hit test code will add undefined to certain values, causing them to turn into NaN. This causes NaNs to propagate through their hit test code, which eventually makes it infinitely loop.
2022-11-05 15:10:13 +00:00
HTML::Window const* default_view() const { return m_window.ptr(); }
LibWeb: Expose the Window object as Document.defaultView This should really be a WindowProxy? but since we don't have anything representing that concept yet, let's just expose the Window object directly so document.defaultView.foo works. :^)
2021-02-21 21:24:11 +01:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
String const& content_type() const { return m_content_type; }
void set_content_type(String content_type) { m_content_type = move(content_type); }
LibWeb: Add contentType attribute to Document
2020-11-13 05:02:15 +00:00
LibWeb: Change Document's m_encoding to Optional<String> This modifies the Document class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value. It also implements the has_encoding() and encoding_or_default() instance methods, the latter of which will return "UTF-8" as a fallback if no encoding is present. The usage of Optional<String> instead of the null string is part of an effort to explicitly indicate that a string could not have a value. This also modifies the former callers of encoding() to use encoding_or_default(). Furthermore, the encoding will now only be set if it is actually known, rather than just guessed by earlier code.
2021-05-12 10:32:41 +02:00
bool has_encoding() const { return m_encoding.has_value(); }
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
Optional<String> const& encoding() const { return m_encoding; }
String encoding_or_default() const { return m_encoding.value_or("UTF-8"_string); }
void set_encoding(Optional<String> encoding) { m_encoding = move(encoding); }
LibWeb: Use standardized encoding names, add encoding attribute to document
2020-11-13 11:16:28 +00:00
// NOTE: These are intended for the JS bindings
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
String character_set() const { return encoding_or_default(); }
String charset() const { return encoding_or_default(); }
String input_encoding() const { return encoding_or_default(); }
LibWeb: Use standardized encoding names, add encoding attribute to document
2020-11-13 11:16:28 +00:00
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 18:32:39 +00:00
bool ready_for_post_load_tasks() const { return m_ready_for_post_load_tasks; }
void set_ready_for_post_load_tasks(bool ready) { m_ready_for_post_load_tasks = ready; }
void completely_finish_loading();
LibWeb: Make DOMImplementation GC-allocated
2022-08-08 15:52:48 +02:00
DOMImplementation* implementation();
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 18:32:39 +00:00
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<HTML::HTMLScriptElement> current_script() const { return m_current_script.ptr(); }
void set_current_script(Badge<HTML::HTMLScriptElement>, JS::GCPtr<HTML::HTMLScriptElement> script) { m_current_script = move(script); }
LibWeb: Flesh out prepare_script and execute_script This fills in a bunch of the FIXMEs that was in prepare_script. execute_script is almost finished, it's just missing the module side. As an aside, let's not assert when inserting a script element with innerHTML.
2021-01-28 20:31:20 +00:00
u32 ignore_destructive_writes_counter() const { return m_ignore_destructive_writes_counter; }
void increment_ignore_destructive_writes_counter() { m_ignore_destructive_writes_counter++; }
void decrement_ignore_destructive_writes_counter() { m_ignore_destructive_writes_counter--; }
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
virtual EventTarget* get_parent(Event const&) override;
LibWeb: Add initial implementation of document.implementation
2020-11-13 06:08:06 +00:00
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String dump_dom_tree_as_json() const;
LibWeb: Add JSON serialization method to DOM::Node This method builds a JSON object representing the full state of the DOM tree. The JSON that is built will be used for building the DOM Inspector widget for the OutOfProcessWebView.
2021-06-07 16:32:24 +01:00
LibWeb: Implement "Document has a style sheet that is blocking scripts" This will be used by the HTML parser to determine whether it's okay to start running a script. Note that we don't actually count the script-blocking style sheets yet. This patch only adds a the checking mechanism for the parser.
2021-09-09 02:11:11 +02:00
bool has_a_style_sheet_that_is_blocking_scripts() const;
LibWeb: Add Document::is_fully_active This is used in a bunch of places in the HTML spec. The current use case for this is History.
2021-09-11 23:28:41 +01:00
bool is_fully_active() const;
LibWeb: Add DOM::Document::is_active() This is a spec concept that means a document is the associated document of its browsing context's active window.
2021-09-19 12:28:22 +02:00
bool is_active() const;
LibWeb: Add Document::is_fully_active This is used in a bunch of places in the HTML spec. The current use case for this is History.
2021-09-11 23:28:41 +01:00
LibWeb: Make History GC-allocated
2022-09-02 13:50:24 +02:00
JS::NonnullGCPtr<HTML::History> history();
LibWeb/HTML: Port Window.history to IDL
2023-03-05 20:21:35 +00:00
JS::NonnullGCPtr<HTML::History> history() const;
LibWeb: Add the History object and stub pushState and replaceState The spec allows us to optionally return from these for any reason. Our reason is that we don't have all the infrastructure in place yet to implement them.
2021-09-11 23:43:34 +01:00
LibJS: Make Heap::allocate<T>() infallible Stop worrying about tiny OOMs. Work towards #20449. While going through these, I also changed the function signature in many places where returning ThrowCompletionOr<T> is no longer necessary.
2023-08-13 13:05:26 +02:00
[[nodiscard]] JS::GCPtr<HTML::Location> location();
LibWeb: Expose the location object via Document.location Both Window.location and Document.location use the same instance of the Location object. Some sites use it via Window, some via Document.
2021-09-12 14:59:49 +01:00
LibWeb: Report if anything is delaying load event, not the count Some elements that delay the load event are more complicated than a simple count will allow for. We'll implement those in a bit!
2023-11-24 15:18:57 +00:00
bool anything_is_delaying_the_load_event() const;
Browser: Show currently loading host and remaining resource count
2022-02-20 17:03:39 -05:00
void increment_number_of_things_delaying_the_load_event(Badge<DocumentLoadEventDelayer>);
void decrement_number_of_things_delaying_the_load_event(Badge<DocumentLoadEventDelayer>);
LibWeb: Allow HTML parser to delay delivery of the document "load" event We will now spin in "the end" until there are no more "things delaying the load event". Of course, nothing actually uses this yet, and there are a lot of things that need to.
2021-09-26 01:03:42 +02:00
LibWeb: Add a "page showing" flag to documents This will be used to determine whether "pageshow" and "pagehide" events are appropriate. We won't actually make use of it until we implement more of history traversal and document unloading.
2021-09-26 12:26:39 +02:00
bool page_showing() const { return m_page_showing; }
void set_page_showing(bool value) { m_page_showing = value; }
LibWeb: Support Document.hidden and Document.visibilityState These just act as if the document is always visible for now.
2021-09-27 16:02:13 +02:00
bool hidden() const;
LibWeb: Make Document::{visibility,read}_state return a StringView Also using the visibility state enum to change strcmp to a simple enum state check :^)
2023-09-12 23:17:07 +12:00
StringView visibility_state() const;
LibWeb: Support Document.hidden and Document.visibilityState These just act as if the document is always visible for now.
2021-09-27 16:02:13 +02:00
LibWeb: Flesh out "document visibility" state a bit more We can now "update the visibility state", which also causes `visibilitychange` events to fire on the document. This still needs GUI integration work at the BrowsingContext level.
2022-09-19 17:17:20 +02:00
// https://html.spec.whatwg.org/multipage/interaction.html#update-the-visibility-state
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
void update_the_visibility_state(HTML::VisibilityState);
LibWeb: Flesh out "document visibility" state a bit more We can now "update the visibility state", which also causes `visibilitychange` events to fire on the document. This still needs GUI integration work at the BrowsingContext level.
2022-09-19 17:17:20 +02:00
LibWeb: Implement Document/BrowsingContext hookup according to spec We now implement the browsing context's "set active document" algorithm from the spec, as well as the "discard" algorithm for browsing contexts and documents.
2022-09-20 21:44:42 +02:00
// NOTE: This does not fire any events, unlike update_the_visibility_state().
void set_visibility_state(Badge<HTML::BrowsingContext>, HTML::VisibilityState);
LibWeb: Let HTML::EventLoop drive the firing of `resize` events
2021-10-03 16:42:03 +02:00
void run_the_resize_steps();
LibWeb: Implement basic "scroll" events at the document level
2022-09-17 17:40:26 +02:00
void run_the_scroll_steps();
LibWeb: Let HTML::EventLoop drive the firing of `resize` events
2021-10-03 16:42:03 +02:00
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 17:41:35 +01:00
void evaluate_media_queries_and_report_changes();
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.
2022-08-28 13:42:07 +02:00
void add_media_query_list(JS::NonnullGCPtr<CSS::MediaQueryList>);
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 17:41:35 +01:00
LibWeb: Implement basic version of CSSOM View's VisualViewport We got some errors while loading https://twinings.co.uk/ about this interface missing, and it looked fairly simple so I sketched it out. Note that I did leave some FIXMEs where it's not clear exactly which metrics we should be returning.
2023-06-17 16:40:35 +02:00
JS::NonnullGCPtr<CSS::VisualViewport> visual_viewport();
LibWeb: Add Document::viewport_rect() This is a convenience helper that returns an empty rect if there is no browsing context (to get the actual rect from).
2023-08-21 12:26:18 +02:00
[[nodiscard]] CSSPixelRect viewport_rect() const;
LibWeb: Implement basic version of CSSOM View's VisualViewport We got some errors while loading https://twinings.co.uk/ about this interface missing, and it looked fairly simple so I sketched it out. Note that I did leave some FIXMEs where it's not clear exactly which metrics we should be returning.
2023-06-17 16:40:35 +02:00
LibWeb: Move viewport subscriptions from BrowsingContext to Document With this change, elements that want to receive viewport rect updates will need to register on document instead of the browsing context. This change solves the problem where a browsing context for a document is guaranteed to exist only while the document is active so browsing context might not exit by the time DOM node that want to register is constructed. This is a part of preparation work before switching to navigables where this issue becomes more visible.
2023-08-23 18:58:42 +02:00
class ViewportClient {
public:
virtual ~ViewportClient() = default;
virtual void did_set_viewport_rect(CSSPixelRect const&) = 0;
};
void register_viewport_client(ViewportClient&);
void unregister_viewport_client(ViewportClient&);
void inform_all_viewport_clients_about_the_current_viewport_rect();
LibWeb: Add Document.hasFocus() stub This always returns true for now. A proper implementation needs to check if the document is in the focused widget within an active window.
2022-02-03 20:06:54 +01:00
bool has_focus() const;
LibWeb: Make document.write() work while document is parsing This necessitated making HTMLParser ref-counted, and having it register itself with Document when created. That makes it possible for scripts to add new input at the current parser insertion point. There is now a reference cycle between Document and HTMLParser. This cycle is explicitly broken by calling Document::detach_parser() at the end of HTMLParser::run(). This is a huge progression on ACID3, from 31% to 49%! :^)
2022-02-21 21:54:21 +01:00
void set_parser(Badge<HTML::HTMLParser>, HTML::HTMLParser&);
void detach_parser(Badge<HTML::HTMLParser>);
LibWeb: Don't parse inline style sheets during HTML fragment parsing Some websites (like Reddit) like to instantiate "components" by setting innerHTML to a huge chunk of stuff. Sometimes those huge chunks of stuff contain inline style sheets (i.e `<style>` elements). Before this change, we would end up parsing the CSS in those elements multiple times, because we had no way of knowing that we were within a fragment parser's temporary document. This patch avoids the extra CSS parsing work by adding adding a flag to Document that tells us it's being used by the fragment parser. Then, we simply avoid parsing CSS for style elements in such documents. The CSS then gets parsed immediately upon insertion into the proper DOM.
2023-08-09 15:10:00 +02:00
void set_is_temporary_document_for_fragment_parsing(Badge<HTML::HTMLParser>) { m_temporary_document_for_fragment_parsing = true; }
[[nodiscard]] bool is_temporary_document_for_fragment_parsing() const { return m_temporary_document_for_fragment_parsing; }
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
static bool is_valid_name(String const&);
LibWeb: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
LibWeb: Validate the qualified name in createDocumentType() 1% progression on ACID3. :^)
2022-02-26 17:26:37 +01:00
struct PrefixAndTagName {
LibWeb: Port validate_and_extract from DeprecatedFlyString
2023-11-05 12:37:49 +13:00
FlyString prefix;
FlyString tag_name;
LibWeb: Validate the qualified name in createDocumentType() 1% progression on ACID3. :^)
2022-02-26 17:26:37 +01:00
};
LibWeb: Port validate_and_extract from DeprecatedFlyString
2023-11-05 12:37:49 +13:00
static WebIDL::ExceptionOr<PrefixAndTagName> validate_qualified_name(JS::Realm&, FlyString const& qualified_name);
LibWeb: Validate the qualified name in createDocumentType() 1% progression on ACID3. :^)
2022-02-26 17:26:37 +01:00
LibWeb: Make NodeIterator GC-allocated
2022-08-08 22:56:19 +02:00
JS::NonnullGCPtr<NodeIterator> create_node_iterator(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
LibWeb: Make TreeWalker GC-allocated
2022-08-08 23:03:27 +02:00
JS::NonnullGCPtr<TreeWalker> create_tree_walker(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
LibWeb: Add basic support for DOM's NodeIterator and NodeFilter This patch adds NodeIterator (created via Document.createNodeIterator()) which allows you to iterate through all the nodes in a subtree while filtering with a provided NodeFilter callback along the way. This first cut implements the full API, but does not yet handle nodes being removed from the document while referenced by the iterator. That will be done in a subsequent patch.
2022-03-09 14:34:32 +01:00
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 16:38:44 +01:00
void register_node_iterator(Badge<NodeIterator>, NodeIterator&);
void unregister_node_iterator(Badge<NodeIterator>, NodeIterator&);
LibWeb: Add an interface to be notified of Document state changes Some HTML elements, e.g. HTMLMediaElement, need to take action when the document becomes inactive.
2023-05-04 08:48:53 -04:00
void register_document_observer(Badge<DocumentObserver>, DocumentObserver&);
void unregister_document_observer(Badge<DocumentObserver>, DocumentObserver&);
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 16:38:44 +01:00
template<typename Callback>
void for_each_node_iterator(Callback callback)
{
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.
2022-08-28 13:42:07 +02:00
for (auto& node_iterator : m_node_iterators)
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 16:38:44 +01:00
callback(*node_iterator);
}
LibWeb: Make document-level style invalidation fast Add a flag to DOM::Document that means the whole document needs a style update. This saves us the trouble of traversing the entire DOM to mark all nodes as needing a style update.
2022-03-19 18:10:59 +01:00
bool needs_full_style_update() const { return m_needs_full_style_update; }
void set_needs_full_style_update(bool b) { m_needs_full_style_update = b; }
LibWeb: Show correct favicon when default favicon is loaded Block the replacement of the favicon by the default favicon loader when a favicon that is loaded through a link tag is already active. This way, the favicon in the link tags will be prioritized against the default favicons from `/favicon.ico` or the seranity default icon.
2022-04-03 19:56:15 +02:00
bool has_active_favicon() const { return m_active_favicon; }
LibWeb: Update displayed favicon when a favicon is loaded When a favicon has been loaded, trigger a favicon update on document level. Of all the link tags in the header, the last favicon that is load should be shown. When the favicon could not be loaded, load the next icon in reverse tree order.
2022-04-03 19:49:38 +02:00
void check_favicon_after_loading_link_resource();
LibWeb: Pass DOM namespace strings as FlyString in more places
2023-11-04 10:19:21 +01:00
JS::GCPtr<HTML::CustomElementDefinition> lookup_custom_element_definition(Optional<FlyString> const& namespace_, FlyString const& local_name, Optional<String> const& is) const;
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
void increment_throw_on_dynamic_markup_insertion_counter(Badge<HTML::HTMLParser>);
void decrement_throw_on_dynamic_markup_insertion_counter(Badge<HTML::HTMLParser>);
LibWeb: Add the "is initial about:blank" flag to DOM::Document
2022-08-01 16:19:55 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#is-initial-about:blank
bool is_initial_about_blank() const { return m_is_initial_about_blank; }
void set_is_initial_about_blank(bool b) { m_is_initial_about_blank = b; }
LibWeb: Align NavigationParams and the creation AOs to the spec And remove assorted spec FIXMEs along the way. Also align populate_session_history_entry_document to the spec, with a bonus spec bug to be filed. This involves creating a new NonFetchSchemeNavigationParams spec, and having the associated AOs take a Variant rather than Optional to accomodate the fact that this extra struct could be returned by the algorithm. We don't actually *do* anything with these params, but the scaffolding is there now, with less TODOs.
2023-09-21 13:47:19 -06:00
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-about-base-url
Optional<AK::URL> about_base_url() const { return m_about_base_url; }
void set_about_base_url(Optional<AK::URL> url) { m_about_base_url = url; }
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String domain() const;
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
void set_domain(String const&);
LibWeb: Implement document.domain getter The document.domain setter is currently stubbed as that is a doozy to implement, given how much restrictions there are in place to try and prevent use of it and potential multi-process implications. This was the only thing preventing us from being able to start displaying ads delivered via Google Syndication.
2022-09-14 15:50:47 +01:00
LibWeb: Implement basic "scroll" events at the document level
2022-09-17 17:40:26 +02:00
auto& pending_scroll_event_targets() { return m_pending_scroll_event_targets; }
auto& pending_scrollend_event_targets() { return m_pending_scrollend_event_targets; }
LibWeb: Set the document "completely loaded time" when appropriate
2022-09-19 13:29:56 +02:00
// https://html.spec.whatwg.org/#completely-loaded
bool is_completely_loaded() const;
LibWeb: Keep more of the navigation parameters in Document
2022-09-19 17:44:37 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-navigation-id
LibWeb: Convert navigationId from DeprecatedString to String
2023-04-10 12:07:24 +03:00
Optional<String> navigation_id() const;
void set_navigation_id(Optional<String>);
LibWeb: Keep more of the navigation parameters in Document
2022-09-19 17:44:37 +02:00
// https://html.spec.whatwg.org/multipage/origin.html#active-sandboxing-flag-set
HTML::SandboxingFlagSet active_sandboxing_flag_set() const;
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-policy-container
HTML::PolicyContainer policy_container() const;
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
// https://html.spec.whatwg.org/multipage/browsers.html#list-of-the-descendant-browsing-contexts
LibWeb: Make BrowsingContext GC-allocated (And BrowsingContextGroup had to come along for the ride as well.) This solves a number of nasty reference cycles between browsing contexts, history items, and their documents.
2022-10-17 11:06:50 +02:00
Vector<JS::Handle<HTML::BrowsingContext>> list_of_descendant_browsing_contexts() const;
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
LibWeb: Implement getting "descendant navigables" of a document
2022-12-16 15:06:55 +01:00
Vector<JS::Handle<HTML::Navigable>> descendant_navigables();
LibWeb: Let NavigableContainers delay the document load event
2023-11-30 21:09:36 +00:00
Vector<JS::Handle<HTML::Navigable>> const descendant_navigables() const;
LibWeb: Implement getting "descendant navigables" of a document
2022-12-16 15:06:55 +01:00
Vector<JS::Handle<HTML::Navigable>> inclusive_descendant_navigables();
LibWeb: Implement getting "ancestor navigables" of a document
2023-08-20 00:34:54 +02:00
Vector<JS::Handle<HTML::Navigable>> ancestor_navigables();
LibWeb: Implement getting "inclusive ancestor navigables" of a document
2023-08-20 00:41:55 +02:00
Vector<JS::Handle<HTML::Navigable>> inclusive_ancestor_navigables();
LibWeb: Implement "document-tree child navigables"
2022-12-16 13:52:12 +01:00
Vector<JS::Handle<HTML::Navigable>> document_tree_child_navigables();
LibWeb: Implement getting "descendant navigables" of a document
2022-12-16 15:06:55 +01:00
LibWeb: Implement "destroy" operation for documents This is basically the old "discard" updated for the world of navigables. Co-authored-by: Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
2022-12-16 23:26:17 +01:00
void destroy();
LibWeb: Implement Document/BrowsingContext hookup according to spec We now implement the browsing context's "set active document" algorithm from the spec, as well as the "discard" algorithm for browsing contexts and documents.
2022-09-20 21:44:42 +02:00
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#abort-a-document
void abort();
LibWeb: Update Document::unload() to match latest spec
2023-04-11 19:40:11 +03:00
// https://html.spec.whatwg.org/multipage/document-lifecycle.html#unload-a-document
void unload(JS::GCPtr<Document> new_document = nullptr);
LibWeb: Flesh out most of the "unload" algorithm for documents Yet another small steps towards spec-compliant document lifecycles.
2022-09-21 01:06:47 +02:00
LibWeb: Implement Document/BrowsingContext hookup according to spec We now implement the browsing context's "set active document" algorithm from the spec, as well as the "discard" algorithm for browsing contexts and documents.
2022-09-20 21:44:42 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#active-parser
LibWeb: Make the HTMLParser GC-allocated This prevents a reference cycle between a HTMLParser opened via document.open() and the document. It was one of many things keeping some documents alive indefinitely.
2022-10-17 10:46:11 +02:00
JS::GCPtr<HTML::HTMLParser> active_parser();
LibWeb: Implement Document/BrowsingContext hookup according to spec We now implement the browsing context's "set active document" algorithm from the spec, as well as the "discard" algorithm for browsing contexts and documents.
2022-09-20 21:44:42 +02:00
LibWeb: Add load/unload timing structures to Document We don't populate these with information just yet, but we will soon!
2022-09-21 00:03:53 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#load-timing-info
LibWeb: Save begin/end timestamps for load and DOMContentLoaded events
2022-09-21 00:43:38 +02:00
DocumentLoadTimingInfo& load_timing_info() { return m_load_timing_info; }
DocumentLoadTimingInfo const& load_timing_info() const { return m_load_timing_info; }
LibWeb: Add load/unload timing structures to Document We don't populate these with information just yet, but we will soon!
2022-09-21 00:03:53 +02:00
void set_load_timing_info(DocumentLoadTimingInfo const& load_timing_info) { m_load_timing_info = load_timing_info; }
// https://html.spec.whatwg.org/multipage/dom.html#previous-document-unload-timing
LibWeb: Save begin/end timestamps for load and DOMContentLoaded events
2022-09-21 00:43:38 +02:00
DocumentUnloadTimingInfo& previous_document_unload_timing() { return m_previous_document_unload_timing; }
DocumentUnloadTimingInfo const& previous_document_unload_timing() const { return m_previous_document_unload_timing; }
LibWeb: Add load/unload timing structures to Document We don't populate these with information just yet, but we will soon!
2022-09-21 00:03:53 +02:00
void set_previous_document_unload_timing(DocumentUnloadTimingInfo const& previous_document_unload_timing) { m_previous_document_unload_timing = previous_document_unload_timing; }
LibWeb+LibWebView+WebContent: Add APIs to manage an autoplay allowlist The spec defines a Permissions Policy to control some browser behaviors on a per-origin basis. Management of these permissions live in their own spec: https://w3c.github.io/webappsec-permissions-policy/ This implements a somewhat ad-hoc Permissions Policy for autoplaying media elements. We will need to implement the entire policy spec for this to be more general.
2023-04-17 13:21:19 -04:00
bool is_allowed_to_use_feature(PolicyControlledFeature) const;
LibWeb: Tear down old layout tree when new document becomes active When a new document becomes the active document of a browsing context, we now notify the old document, allowing it to tear down its layout tree. In the future, there might be more cleanups we'd like to do here.
2022-10-16 15:53:15 +02:00
void did_stop_being_active_document_in_browsing_context(Badge<HTML::BrowsingContext>);
LibWeb: Add did_stop_being_active_document_in_navigable()
2023-09-04 00:02:15 +02:00
void did_stop_being_active_document_in_navigable();
LibWeb: Tear down old layout tree when new document becomes active When a new document becomes the active document of a browsing context, we now notify the old document, allowing it to tear down its layout tree. In the future, there might be more cleanups we'd like to do here.
2022-10-16 15:53:15 +02:00
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
bool query_command_supported(String const&) const;
LibWeb: Stub Document.queryCommandSupported
2022-11-05 14:48:57 +00:00
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String dump_accessibility_tree_as_json();
LibWeb: Add Functionality to Dump to Accessibility Tree This will be used to display the accessibility tree in the inspector.
2022-12-11 10:56:37 -06:00
LibWeb: Implement Document::make_active() Implementation of "make active" algorithm from the spec for Document. Co-authored-by: Andreas Kling <kling@serenityos.org>
2023-04-23 19:39:12 +03:00
void make_active();
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
void set_salvageable(bool value) { m_salvageable = value; }
LibWeb: Implement "attempt to populate the history entry's document" Implements: https://html.spec.whatwg.org/multipage/browsing-the-web.html#attempt-to-populate-the-history-entry's-document This is going to be a replacement for `FrameLoader::load()` after switching to navigables. Brief description of `populate_session_history_entry_document`: - If navigation params have url with fetch scheme then DOM document will be populated by fetching url and parsing response. This is going to be a replacement for `FrameLoader::load(AK::URL&)`. - If url in navigation params is abort:srcdoc then DOM document will be populated by parsing HTML text passed in document resource. This is going to be a replacement for `FrameLoader::load_html()`
2023-04-06 18:10:12 +03:00
LibWeb: Add class to represent "list of available images" from HTML spec
2023-05-11 06:12:45 +02:00
HTML::ListOfAvailableImages& list_of_available_images();
HTML::ListOfAvailableImages const& list_of_available_images() const;
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
void register_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, IntersectionObserver::IntersectionObserver&);
void unregister_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, IntersectionObserver::IntersectionObserver&);
void run_the_update_intersection_observations_steps(HighResolutionTime::DOMHighResTimeStamp time);
LibWeb: Extract shared lazy-loading behavior into a base class `<iframe>` and `<img>` tags share the same spec for several aspects of lazy-loading: how the `loading` attribute works, the "will lazy load element" steps, and a member for storing the lazy-load resumption steps. So let's share the implementation by using a base class. This mostly involves moving things around. However, we also change the `start_intersection_observing_a_lazy_loading_element()` method to take a LazyLoadingElement, and operate on one, instead of always casting to HTMLImageElement. We do unfortunately have to do some shenanigans to make the cast work, by adding a virtual function stub in DOM::Element.
2023-11-21 18:50:09 +00:00
void start_intersection_observing_a_lazy_loading_element(Element&);
LibWeb: Implement `loading=lazy` for `<img>` elements
2023-07-07 00:00:06 +01:00
LibWeb: Implement `<meta http-equiv="Refresh">` Required by Atlassian to continue to their authorization process. Also used by the SerenityOS FAQ redirect on the website, the Bootstrap documentation for going to older versions from the dropdown and likely several other sites.
2023-07-28 02:20:57 +01:00
void shared_declarative_refresh_steps(StringView input, JS::GCPtr<HTML::HTMLMetaElement const> meta_element = nullptr);
LibWeb: Make Document::determine_the_indicated_part public We need to call this from NavigateEvent as part of the Navigation API.
2023-08-23 18:26:16 -06:00
struct TopOfTheDocument { };
using IndicatedPart = Variant<Element*, TopOfTheDocument>;
IndicatedPart determine_the_indicated_part() const;
LibWeb: Expose a getter for Document's unload_counter We need to check this value from the Navigation APIs.
2023-08-24 16:17:45 -06:00
u32 unload_counter() const { return m_unload_counter; }
LibWeb: Implement snapshotting source snapshot params per the spec
2023-08-25 20:34:50 -06:00
HTML::SourceSnapshotParams snapshot_source_snapshot_params() const;
LibWeb: Start fleshing out update document for history step application
2023-09-23 22:59:27 +02:00
void update_for_history_step_application(JS::NonnullGCPtr<HTML::SessionHistoryEntry>, bool do_not_reactive, size_t script_history_length, size_t script_history_index);
LibWeb+LibJS: Use JS::GCPtr for pointers to GC-allocated objects Fixes warnings found by LibJSGCVerifier
2023-12-11 12:23:04 +01:00
HashMap<AK::URL, JS::GCPtr<HTML::SharedImageRequest>>& shared_image_requests();
LibWeb: Forbid sharing image requests across documents This change addresses the bug where images unable to load when the reload button in the UI is clicked repeatedly. Before this fix, it was possible to use SharedImageRequests across multiple documents. However, when the document that initiated the request is gone, tasks scheduled on the event loop remain in the fetching state because the originating document is no longer active. Furthermore, another reason to prohibit the sharing of image requests across documents is that the "Origin" header in an image request is dependent on the document.
2023-10-17 16:52:16 +02:00
LibWeb: Add a default DocumentTimeline object to DOM::Document
2023-11-04 08:38:46 -07:00
JS::NonnullGCPtr<Animations::DocumentTimeline> timeline();
LibWeb: Store all timelines associated with a document on the document This will be required for propagating the current animation time to all relevant timelines, which each propagate that time to all of their relevant animations.
2023-11-04 08:43:10 -07:00
void associate_with_timeline(JS::NonnullGCPtr<Animations::AnimationTimeline>);
void disassociate_with_timeline(JS::NonnullGCPtr<Animations::AnimationTimeline>);
LibWeb: Add Document's pending animation event queue This is needed for Animation's update finished state procedure
2023-11-04 13:35:30 -07:00
struct PendingAnimationEvent {
JS::NonnullGCPtr<DOM::Event> event;
JS::NonnullGCPtr<Animations::Animation> target;
Optional<double> scheduled_event_time;
};
void append_pending_animation_event(PendingAnimationEvent const&);
LibWeb: Wait until new document becomes active before running scripts Fixes https://github.com/SerenityOS/serenity/issues/22485 With this change WebContent does not crash when `location.reload()` is invoked but `Navigable::reload()` still not working because of spec issue (https://github.com/whatwg/html/issues/9869) so we can't add a test yet.
2023-12-30 15:45:10 +01:00
bool ready_to_run_scripts() const { return m_ready_to_run_scripts; }
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.
2022-08-28 13:42:07 +02:00
protected:
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 08:41:28 +02:00
virtual void initialize(JS::Realm&) override;
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.
2022-08-28 13:42:07 +02:00
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Remove unecessary dependence on Window from DOM and WebIDL These classes only needed Window to get at its realm. Pass a realm directly to construct DOM and WebIDL classes. This change importantly removes the guarantee that a Document will always have a non-null Window object. Only Documents created by a BrowsingContext will have a non-null Window object. Documents created by for example, DocumentFragment, will not have a Window (soon). This incremental commit leaves some workarounds in place to keep other parts of the code building.
2022-09-25 16:15:49 -06:00
Document(JS::Realm&, AK::URL const&);
LibWeb: Fix Document construction mishap in <template> element Ref-counted objects must not be stack allocated. Make DOM::Document's constructor private to avoid this issue. (I wish we could mark classes as heap-only..)
2020-10-23 08:31:26 +02:00
LibWeb: Add XMLDocument stub Required by old versions of Pixi.js's XMLFormat bitmap font loader. https://github.com/pixijs/pixijs/blob/db824181dc3dfffa0951fb8579282ba8e654cb3b/packages/text-bitmap/src/formats/XMLFormat.ts#L16
2023-04-05 23:00:08 +01:00
private:
LibWeb: Basic implementation of global event handlers :^) Document and HTMLElement now inherit from HTML::GlobalEventHandlers which allows them to support "onfoo" event handler attributes. These are assignable both via IDL attributes and content attributes. Event listeners constructed this way get a special "attribute" flag on them so we know which one to replace if you reassign them. This also allows them to coexist with EventTarget.addEventListener(). This is all a bit sloppy, but it works decently for a first cut. The Window object should also inherit GlobalEventHandlers, but since we don't generate it from IDL, I haven't taken that step here. Also this would be a lot nicer if we supported IDL mixins.
2021-02-03 22:47:50 +01:00
// ^HTML::GlobalEventHandlers
LibWeb: Port {HTML,UIEvents,XHR}::EventNames to new String
2023-04-06 07:25:18 +02:00
virtual EventTarget& global_event_handlers_to_event_target(FlyString const&) final { return *this; }
LibWeb: Basic implementation of global event handlers :^) Document and HTMLElement now inherit from HTML::GlobalEventHandlers which allows them to support "onfoo" event handler attributes. These are assignable both via IDL attributes and content attributes. Event listeners constructed this way get a special "attribute" flag on them so we know which one to replace if you reassign them. This also allows them to coexist with EventTarget.addEventListener(). This is all a bit sloppy, but it works decently for a first cut. The Window object should also inherit GlobalEventHandlers, but since we don't generate it from IDL, I haven't taken that step here. Also this would be a lot nicer if we supported IDL mixins.
2021-02-03 22:47:50 +01:00
LibWeb: Tear down layout trees properly Instead of just ripping out the root of the layout tree from its RefPtr in Document, actually go through the DOM and gather up all the layout nodes. Then destroy them all in one swoop. Also, make sure to do this when detaching Document from Frame, to enforce the invariant that layout only occurs in framed documents.
2020-10-20 17:43:13 +02:00
void tear_down_layout_tree();
LibWeb: Clear all active timers when document is destroyed This change implements a step from the document's destroy procedure in the specification, saying that all active timers should be cleared. By doing this, we also fix the leaking of a document in case where we have navigated away from a page that has scheduled timers that haven't yet been triggered.
2023-09-26 11:44:56 +02:00
void run_unloading_cleanup_steps();
LibWeb: Evaluate @media CSS rules when updating style In case we have new @media rules, we need to make sure we've evaluated them before actually recomputing styles for the document.
2022-03-20 16:18:43 +01:00
void evaluate_media_rules();
LibWeb: Make Document::run_the_document_write_steps take a StringView Which flows on down into HTMLTokenizer::insert_input_at_insertion_point.
2023-09-12 23:16:10 +12:00
WebIDL::ExceptionOr<void> run_the_document_write_steps(StringView);
LibWeb: Append only one line feed character in Document.writeln There were a couple issues here: 1. The line feed should only be appended once, rather than one per string. 2. The new_strings list of strings was unused (we were creating the new list, then passing the old list to Document.write).
2022-02-21 16:34:54 -05:00
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
void queue_intersection_observer_task();
void queue_an_intersection_observer_entry(IntersectionObserver::IntersectionObserver&, HighResolutionTime::DOMHighResTimeStamp time, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> root_bounds, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> bounding_client_rect, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, JS::NonnullGCPtr<Element> target);
LibWeb: Port get_element_by_id from DeprecatedFlyString We needed to keep the old versions of these functions around before all of the IDL interfaces were ported over to new AK String, but now that is done, we can remove the deprecated versions of these functions.
2023-10-08 13:34:11 +13:00
Element* find_a_potential_indicated_element(FlyString const& fragment) const;
LibWeb: Implement algorithms for determining an indicated element
2023-08-11 20:20:09 +01:00
LibWeb: Let Document have a direct GCPtr to its containing Web::Page With this change, Document now always has a Web::Page. This means we no longer rely on the breakable link between Document and BrowsingContext to find a relevant Web::Page. Fixes #22290
2023-12-15 13:43:39 +01:00
JS::NonnullGCPtr<Page> m_page;
LibWeb: Rename CSS::StyleResolver => StyleComputer Resolved style is a spec concept that refers to the weird mix of computed style and used style reflected by getComputedStyle(). The purpose of this class is to produce the *computed* style for a given element, so let's call it StyleComputer.
2021-09-24 13:49:57 +02:00
OwnPtr<CSS::StyleComputer> m_style_computer;
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<CSS::StyleSheetList> m_style_sheets;
JS::GCPtr<Node> m_hovered_node;
JS::GCPtr<Node> m_inspected_node;
LibWeb: Wrap PseudoElements stored in SimpleSelector in a class No functional impact intended. This is just a more complicated way of writing what we have now. The goal of this commit is so that we are able to store the 'name' of a pseudo element for use in serializing 'unknown -webkit- pseudo-elements', see: https://www.w3.org/TR/selectors-4/#compat This is quite awkward, as in pretty much all cases just the selector type enum is enough, but we will need to cache the name for serializing these unknown selectors. I can't figure out any reason why we would need this name anywhere else in the engine, so pretty much everywhere is still just passing around this raw enum. But this change will allow us to easily store the name inside of this new struct for when it is needed for serialization, once those webkit unknown elements are supported by our engine.
2023-12-10 21:00:03 +13:00
Optional<CSS::Selector::PseudoElement::Type> m_inspected_pseudo_element;
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<Node> m_active_favicon;
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 15:01:28 +01:00
WeakPtr<HTML::BrowsingContext> m_browsing_context;
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
AK::URL m_url;
LibHTML: Parse link, alink and vlink in <body> and pass to Document This patch adds HTMLBodyElement::parse_attribute() where we extract the link colors and stash them away on Document.
2019-10-06 10:11:54 +02:00
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<HTML::Window> m_window;
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 18:53:28 +02:00
LibWeb: Rename Layout::InitialContainingBlock to Layout::Viewport The name "initial containing block" was wrong for this, as it doesn't correspond to the HTML element, and that's specifically what it's supposed to do! :^)
2023-02-25 11:04:29 +01:00
JS::GCPtr<Layout::Viewport> m_layout_root;
LibHTML: Move layout root from HtmlView to Document The layout root is now kept alive via Document::m_layout_root. This will allow us to do more layout-related things inside the inner layer of LibHTML without reaching out to the HtmlView. I'd like to keep HtmlView at a slightly higher level, to prevent it from getting too complex. This patch also fixes accidental disconnection of the layout tree from the DOM after doing a layout tree rebuild. ~LayoutNode() now only unsets the DOM node's layout_node() if it's itself.
2019-10-13 12:34:25 +02:00
LibDraw+LibHTML: Make link colors themeable Add "Link", "ActiveLink" and "VisitedLink" colors to the system theme definition, and implement support for them in LibHTML. Note that <body link="foo" alink="bar" vlink="baz"> takes precedence over the system colors. Author style also takes precedence, since we only fetch the system color in case the CSS color is -libhtml-link.
2020-01-13 20:33:15 +01:00
Optional<Color> m_link_color;
Optional<Color> m_active_link_color;
Optional<Color> m_visited_link_color;
LibHTML: Batch style updates and make them start from the root Use a zero-timer to schedule a style update after invalidating style on any node. Nodes now have a needs_style_update flag which helps us batch and coalesce the work. We also start style updates at the root and work our way through the document, updating any node that has the needs_style_update flag set. This is slower than what we were doing before, but far more correct. There is a ton of room for improvement here. :^)
2019-10-19 18:57:02 +02:00
LibWeb: Use Core::Timer for style and layout update timers in Document Fixes leaking of DOM::Document by capturing it into JS::SafeFunction callback when using Platform::Timer for style and layout update timers.
2023-07-20 12:59:03 +02:00
RefPtr<Core::Timer> m_style_update_timer;
RefPtr<Core::Timer> m_layout_update_timer;
LibHTML: Store the HTML parser input along with the created Document This will allow us to "view source" later on, long after parsing has finished and turned it into a DOM.
2019-11-25 00:27:41 +01:00
LibWeb: Make the HTMLParser GC-allocated This prevents a reference cycle between a HTMLParser opened via document.open() and the document. It was one of many things keeping some documents alive indefinitely.
2022-10-17 10:46:11 +02:00
JS::GCPtr<HTML::HTMLParser> m_parser;
LibWeb: Add basic support for dynamic markup insertion This implements basic support for dynamic markup insertion, adding * Document::open() * Document::write(Vector<String> const&) * Document::writeln(Vector<String> const&) * Document::close() The HTMLParser is modified to make it possible to create a script-created parser which initially only contains a HTMLTokenizer without any data. Aditionally the HTMLParser::run method gains an overload which does not modify the Document and does not run HTMLParser::the_end() so that we can reenter the parser at a later time. Furthermore all FIXMEs that consern the insertion point are implemented wich is defined in the HTMLTokenizer. Additionally the following member-variables of the HTMLParser are now exposed by getter funcions: * m_tokenizer * m_aborted * m_script_nesting_level The HTMLTokenizer is modified so that it contains an insertion point which keeps track of where the next input from the Document::write functions will be inserted. The insertion point is implemented as the charakter offset into m_decoded_input and a boolean describing if the insertion point is defined. Functions to update, check and {re}store the insertion point are also added. The function HTMLTokenizer::insert_eof is added to tell a script-created parser that document::close was called and HTMLParser::the_end() should be called. Lastly an explicit default constructor is added to HTMLTokenizer to create a empty HTMLTokenizer into which data can be inserted.
2022-02-19 15:58:21 +01:00
bool m_active_parser_was_aborted { false };
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String m_source;
LibWeb: Parse <script> elements and run any JavaScript found inside This patch begins integrating LibJS into LibWeb. Document holds the JS::Interpreter for now, and it is created on demand when you first call Document::interpreter(). We also add a simple "alert()" function to the global object.
2020-03-14 12:41:51 +01:00
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<HTML::HTMLScriptElement> m_pending_parsing_blocking_script;
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 17:36:47 +02:00
LibWeb: Do not use JS::Handle for "scripts to execute" in DOM::Document Using JS::Handle in members of GC-allocated object almost always leaks. Instead we should visit these members in visit_edges().
2023-09-27 17:27:47 +02:00
Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>> m_scripts_to_execute_when_parsing_has_finished;
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 17:36:47 +02:00
// https://html.spec.whatwg.org/multipage/scripting.html#list-of-scripts-that-will-execute-in-order-as-soon-as-possible
LibWeb: Do not use JS::Handle for "scripts to execute" in DOM::Document Using JS::Handle in members of GC-allocated object almost always leaks. Instead we should visit these members in visit_edges().
2023-09-27 17:27:47 +02:00
Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>> m_scripts_to_execute_in_order_as_soon_as_possible;
LibWeb: Add "scripts to execute in order as soon as possible" Previously, we had accidentally conflated this set with the similar-but-distinct "scripts to execute as soon as possible".
2022-09-17 17:36:47 +02:00
// https://html.spec.whatwg.org/multipage/scripting.html#set-of-scripts-that-will-execute-as-soon-as-possible
LibWeb: Do not use JS::Handle for "scripts to execute" in DOM::Document Using JS::Handle in members of GC-allocated object almost always leaks. Instead we should visit these members in visit_edges().
2023-09-27 17:27:47 +02:00
Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>> m_scripts_to_execute_as_soon_as_possible;
LibWeb: Add a "quirks mode" flag to Document This doesn't do anything yet, but it will sooner or later. :^)
2020-05-28 00:20:36 +02:00
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 21:17:17 +01:00
QuirksMode m_quirks_mode { QuirksMode::No };
LibWeb: Add the type field to DOM::Document This patch adds the document type concept to documents and sets it in various places.
2022-07-03 21:44:00 +02:00
// https://dom.spec.whatwg.org/#concept-document-type
Type m_type { Type::HTML };
LibWeb: Only allow editing of elements with contenteditable="true" We now respect the contenteditable HTML attribute and only let you edit content inside explicitly editable elements.
2020-08-02 16:05:59 +02:00
bool m_editable { false };
LibWeb: Allow focusing individual (focusable) elements with Tab key You can now cycle through focusable elements (currently only hyperlinks are focusable) with the Tab key. The focus outline is rendered in a new FocusOutline paint phase.
2020-08-14 19:40:37 +02:00
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<Element> m_focused_element;
JS::GCPtr<Element> m_active_element;
LibWeb: Give Document a "target element" The target element is the one matching the URL fragment. We don't yet set it to anything.
2023-08-11 20:14:44 +01:00
JS::GCPtr<Element> m_target_element;
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
bool m_created_for_appropriate_template_contents { false };
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<Document> m_associated_inert_template_document;
LibWeb: Update "appropriate template contents owner document" AO This was moved from HTMLTemplateElement to Document at some point, so let's match the spec and move it here too.
2022-10-29 13:06:24 +02:00
JS::GCPtr<Document> m_appropriate_template_contents_owner_document;
LibWeb: Implement document ready state
2020-08-31 13:56:16 +01:00
LibWeb: Implement "update the current document readiness" from spec The only difference from what we were already doing is that setting the same ready state twice no longer fires a "readystatechange" event. I don't think that could happen in practice though.
2021-09-26 12:22:16 +02:00
HTML::DocumentReadyState m_readiness { HTML::DocumentReadyState::Loading };
LibWeb: Port Document interface from DeprecatedString to String
2023-09-15 21:46:58 +12:00
String m_content_type { "application/xml"_string };
Optional<String> m_encoding;
LibWeb: Add initial implementation of document.implementation
2020-11-13 06:08:06 +00:00
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 18:32:39 +00:00
bool m_ready_for_post_load_tasks { false };
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.
2022-08-28 13:42:07 +02:00
JS::GCPtr<DOMImplementation> m_implementation;
JS::GCPtr<HTML::HTMLScriptElement> m_current_script;
LibWeb: Add hack to disable StyleInvalidator while parsing document Running a StyleInvalidator for every attribute set in a new document was making it impossible to load larger sites. :^)
2020-12-15 18:53:35 +01:00
bool m_should_invalidate_styles_on_attribute_changes { true };
LibWeb: Flesh out prepare_script and execute_script This fills in a bunch of the FIXMEs that was in prepare_script. execute_script is almost finished, it's just missing the module side. As an aside, let's not assert when inserting a script element with innerHTML.
2021-01-28 20:31:20 +00:00
u32 m_ignore_destructive_writes_counter { 0 };
LibWeb: Implement "Document has a style sheet that is blocking scripts" This will be used by the HTML parser to determine whether it's okay to start running a script. Note that we don't actually count the script-blocking style sheets yet. This patch only adds a the checking mechanism for the parser.
2021-09-09 02:11:11 +02:00
LibWeb: Add basic support for dynamic markup insertion This implements basic support for dynamic markup insertion, adding * Document::open() * Document::write(Vector<String> const&) * Document::writeln(Vector<String> const&) * Document::close() The HTMLParser is modified to make it possible to create a script-created parser which initially only contains a HTMLTokenizer without any data. Aditionally the HTMLParser::run method gains an overload which does not modify the Document and does not run HTMLParser::the_end() so that we can reenter the parser at a later time. Furthermore all FIXMEs that consern the insertion point are implemented wich is defined in the HTMLTokenizer. Additionally the following member-variables of the HTMLParser are now exposed by getter funcions: * m_tokenizer * m_aborted * m_script_nesting_level The HTMLTokenizer is modified so that it contains an insertion point which keeps track of where the next input from the Document::write functions will be inserted. The insertion point is implemented as the charakter offset into m_decoded_input and a boolean describing if the insertion point is defined. Functions to update, check and {re}store the insertion point are also added. The function HTMLTokenizer::insert_eof is added to tell a script-created parser that document::close was called and HTMLParser::the_end() should be called. Lastly an explicit default constructor is added to HTMLTokenizer to create a empty HTMLTokenizer into which data can be inserted.
2022-02-19 15:58:21 +01:00
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#unload-counter
u32 m_unload_counter { 0 };
// https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#throw-on-dynamic-markup-insertion-counter
u32 m_throw_on_dynamic_markup_insertion_counter { 0 };
LibWeb: Implement "Document has a style sheet that is blocking scripts" This will be used by the HTML parser to determine whether it's okay to start running a script. Note that we don't actually count the script-blocking style sheets yet. This patch only adds a the checking mechanism for the parser.
2021-09-09 02:11:11 +02:00
// https://html.spec.whatwg.org/multipage/semantics.html#script-blocking-style-sheet-counter
u32 m_script_blocking_style_sheet_counter { 0 };
LibWeb: Add the History object and stub pushState and replaceState The spec allows us to optionally return from these for any reason. Our reason is that we don't have all the infrastructure in place yet to implement them.
2021-09-11 23:43:34 +01:00
LibWeb: Make History GC-allocated
2022-09-02 13:50:24 +02:00
JS::GCPtr<HTML::History> m_history;
LibWeb: Allow HTML parser to delay delivery of the document "load" event We will now spin in "the end" until there are no more "things delaying the load event". Of course, nothing actually uses this yet, and there are a lot of things that need to.
2021-09-26 01:03:42 +02:00
size_t m_number_of_things_delaying_the_load_event { 0 };
LibWeb: Add a "page showing" flag to documents This will be used to determine whether "pageshow" and "pagehide" events are appropriate. We won't actually make use of it until we implement more of history traversal and document unloading.
2021-09-26 12:26:39 +02:00
LibWeb: Implement Document/BrowsingContext hookup according to spec We now implement the browsing context's "set active document" algorithm from the spec, as well as the "discard" algorithm for browsing contexts and documents.
2022-09-20 21:44:42 +02:00
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#concept-document-salvageable
bool m_salvageable { true };
LibWeb: Add a "page showing" flag to documents This will be used to determine whether "pageshow" and "pagehide" events are appropriate. We won't actually make use of it until we implement more of history traversal and document unloading.
2021-09-26 12:26:39 +02:00
// https://html.spec.whatwg.org/#page-showing
bool m_page_showing { false };
LibWeb: Let HTML::EventLoop drive the firing of `resize` events
2021-10-03 16:42:03 +02:00
// Used by run_the_resize_steps().
Gfx::IntSize m_last_viewport_size;
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 17:41:35 +01:00
LibWeb: Move viewport subscriptions from BrowsingContext to Document With this change, elements that want to receive viewport rect updates will need to register on document instead of the browsing context. This change solves the problem where a browsing context for a document is guaranteed to exist only while the document is active so browsing context might not exit by the time DOM node that want to register is constructed. This is a part of preparation work before switching to navigables where this issue becomes more visible.
2023-08-23 18:58:42 +02:00
HashTable<ViewportClient*> m_viewport_clients;
LibWeb: Implement basic "scroll" events at the document level
2022-09-17 17:40:26 +02:00
// https://w3c.github.io/csswg-drafts/cssom-view-1/#document-pending-scroll-event-targets
Vector<JS::NonnullGCPtr<EventTarget>> m_pending_scroll_event_targets;
// https://w3c.github.io/csswg-drafts/cssom-view-1/#document-pending-scrollend-event-targets
Vector<JS::NonnullGCPtr<EventTarget>> m_pending_scrollend_event_targets;
LibWeb: Fire MediaQueryListEvents when an MQL's match-state changes The HTML event loop does a check for MQL match-state changes and dispatches the events. This requires us to keep a list of MQLs on the Document.
2021-10-04 17:41:35 +01:00
// Used by evaluate_media_queries_and_report_changes().
Vector<WeakPtr<CSS::MediaQueryList>> m_media_query_lists;
LibWeb: Make CSS layout lazier Instead of doing layout synchronously whenever something changes, we now use a basic event loop timer to defer and coalesce relayouts. If you did something that requires a relayout of the page, make sure to call Document::set_needs_layout() and it will get coalesced with all the other layout updates. There's lots of room for improvement here, but this already makes many web pages significantly snappier. :^) Also, note that this exposes a number of layout bugs where we have been relying on multiple relayouts to calculate the correct dimensions for things. Now that we only do a single layout in many cases, these kind of problems are much more noticeable. That should also make them easier to figure out and fix. :^)
2021-10-05 22:30:53 +02:00
bool m_needs_layout { false };
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 16:38:44 +01:00
LibWeb: Make document-level style invalidation fast Add a flag to DOM::Document that means the whole document needs a style update. This saves us the trouble of traversing the entire DOM to mark all nodes as needing a style update.
2022-03-19 18:10:59 +01:00
bool m_needs_full_style_update { false };
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
HashTable<JS::GCPtr<NodeIterator>> m_node_iterators;
LibWeb: Add the "is initial about:blank" flag to DOM::Document
2022-08-01 16:19:55 +02:00
LibWeb: Add an interface to be notified of Document state changes Some HTML elements, e.g. HTMLMediaElement, need to take action when the document becomes inactive.
2023-05-04 08:48:53 -04:00
HashTable<JS::NonnullGCPtr<DocumentObserver>> m_document_observers;
LibWeb: Add the "is initial about:blank" flag to DOM::Document
2022-08-01 16:19:55 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#is-initial-about:blank
bool m_is_initial_about_blank { false };
LibWeb: Store document origin as a HTML::Origin object This will allow us to remember an arbitrary origin instead of deriving it from the document's URL.
2022-08-05 10:54:01 +02:00
LibWeb: Align NavigationParams and the creation AOs to the spec And remove assorted spec FIXMEs along the way. Also align populate_session_history_entry_document to the spec, with a bonus spec bug to be filed. This involves creating a new NonFetchSchemeNavigationParams spec, and having the associated AOs take a Variant rather than Optional to accomodate the fact that this extra struct could be returned by the algorithm. We don't actually *do* anything with these params, but the scaffolding is there now, with less TODOs.
2023-09-21 13:47:19 -06:00
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-about-base-url
Optional<AK::URL> m_about_base_url;
LibWeb: Bring browsing context creation closer to spec This patch implements the "create a new browsing context" function from the HTML spec and replaces our existing logic with it. The big difference is that browsing contexts now initially navigate to "about:blank" instead of starting out in a strange "empty" state. This makes it possible for websites to create a new iframe and start scripting inside it right away, without having to load an URL into it.
2022-08-05 10:55:47 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-coop
HTML::CrossOriginOpenerPolicy m_cross_origin_opener_policy;
LibWeb: Add API for setting a document's referrer
2022-08-05 10:55:01 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#the-document's-referrer
LibWeb: Port DOM::Document from DeprecatedString
2023-12-03 08:58:43 +13:00
String m_referrer;
LibWeb: Add API for setting a document's referrer
2022-08-05 10:55:01 +02:00
LibWeb: Store document origin as a HTML::Origin object This will allow us to remember an arbitrary origin instead of deriving it from the document's URL.
2022-08-05 10:54:01 +02:00
// https://dom.spec.whatwg.org/#concept-document-origin
HTML::Origin m_origin;
LibWeb: Make Document vend the same HTMLCollections every time
2022-09-18 02:02:52 +02:00
JS::GCPtr<HTMLCollection> m_applets;
JS::GCPtr<HTMLCollection> m_anchors;
JS::GCPtr<HTMLCollection> m_images;
JS::GCPtr<HTMLCollection> m_embeds;
JS::GCPtr<HTMLCollection> m_links;
JS::GCPtr<HTMLCollection> m_forms;
JS::GCPtr<HTMLCollection> m_scripts;
LibWeb: Implement basic support for Document.all The finer details are missing here, but the basic API is up.
2022-09-18 02:17:11 +02:00
JS::GCPtr<HTMLCollection> m_all;
LibWeb: Set the document "completely loaded time" when appropriate
2022-09-19 13:29:56 +02:00
// https://html.spec.whatwg.org/#completely-loaded-time
Userland: Remove remaining users of Duration::now_realtime() This is a clear sign that they want to use a UnixDateTime instead. This also adds support for placing durations and date times into SQL databases via their millisecond offset to UTC.
2023-03-13 22:35:22 +01:00
Optional<AK::UnixDateTime> m_completely_loaded_time;
LibWeb: Flesh out "document visibility" state a bit more We can now "update the visibility state", which also causes `visibilitychange` events to fire on the document. This still needs GUI integration work at the BrowsingContext level.
2022-09-19 17:17:20 +02:00
LibWeb: Keep more of the navigation parameters in Document
2022-09-19 17:44:37 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-navigation-id
LibWeb: Convert navigationId from DeprecatedString to String
2023-04-10 12:07:24 +03:00
Optional<String> m_navigation_id;
LibWeb: Keep more of the navigation parameters in Document
2022-09-19 17:44:37 +02:00
// https://html.spec.whatwg.org/multipage/origin.html#active-sandboxing-flag-set
HTML::SandboxingFlagSet m_active_sandboxing_flag_set;
// https://html.spec.whatwg.org/multipage/dom.html#concept-document-policy-container
HTML::PolicyContainer m_policy_container;
LibWeb: Flesh out "document visibility" state a bit more We can now "update the visibility state", which also causes `visibilitychange` events to fire on the document. This still needs GUI integration work at the BrowsingContext level.
2022-09-19 17:17:20 +02:00
// https://html.spec.whatwg.org/multipage/interaction.html#visibility-state
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
HTML::VisibilityState m_visibility_state { HTML::VisibilityState::Hidden };
LibWeb: Add load/unload timing structures to Document We don't populate these with information just yet, but we will soon!
2022-09-21 00:03:53 +02:00
// https://html.spec.whatwg.org/multipage/dom.html#load-timing-info
DocumentLoadTimingInfo m_load_timing_info;
// https://html.spec.whatwg.org/multipage/dom.html#previous-document-unload-timing
DocumentUnloadTimingInfo m_previous_document_unload_timing;
LibWeb: Make Window.getSelection() forward to Document.getSelection() (And have document create the Selection object on demand.)
2022-10-10 21:23:03 +02:00
LibWeb: Add spec link for DOM::Document::m_selection
2022-10-11 12:24:57 +02:00
// https://w3c.github.io/selection-api/#dfn-selection
LibWeb: Make Window.getSelection() forward to Document.getSelection() (And have document create the Selection object on demand.)
2022-10-10 21:23:03 +02:00
JS::GCPtr<Selection::Selection> m_selection;
LibWeb: Cache the first <base href> (in tree order) in Document When parsing relative URLs, we have to check the first <base href> in tree order (if one is available). This was getting *very* costly on large DOMs with many relative urls. This patch avoids all that repeated traversal by letting Document cache the first <base href> and invalidating the cache whenever a <base> element is added/removed/edited in the DOM. The browser was stuck doing this for a *very* long time when loading the ECMA-262 spec, and this removes that problem entirely.
2022-11-04 20:56:30 +01:00
// NOTE: This is a cache to make finding the first <base href> element O(1).
LibWeb: Fix a few const-ness issues
2023-02-25 10:44:51 -07:00
JS::GCPtr<HTML::HTMLBaseElement const> m_first_base_element_with_href_in_tree_order;
LibWeb: Add class to represent "list of available images" from HTML spec
2023-05-11 06:12:45 +02:00
// https://html.spec.whatwg.org/multipage/images.html#list-of-available-images
LibWeb: Make HTML::DecodedImageData to be GC-allocated This change fixes GC-leak caused by following mutual dependency: - SVGDecodedImageData owns JS::Handle for Page. - SVGDecodedImageData is owned by visited objects. by making everything inherited from HTML::DecodedImageData and ListOfAvailableImages to be GC-allocated. Generally, if visited object has a handle, very likely we leak everything visited from object in a handle.
2023-12-12 20:07:19 +01:00
JS::GCPtr<HTML::ListOfAvailableImages> m_list_of_available_images;
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
LibWeb: Implement basic version of CSSOM View's VisualViewport We got some errors while loading https://twinings.co.uk/ about this interface missing, and it looked fairly simple so I sketched it out. Note that I did leave some FIXMEs where it's not clear exactly which metrics we should be returning.
2023-06-17 16:40:35 +02:00
JS::GCPtr<CSS::VisualViewport> m_visual_viewport;
LibWeb: Add initial implementation of IntersectionObserver The main missing features are rootMargin, proper nested browsing context support and content clip/clip-path support. This makes images appear on some sites, such as YouTube and howstuffworks.com.
2023-07-06 23:44:07 +01:00
// NOTE: Not in the spec per say, but Document must be able to access all IntersectionObservers whose root is in the document.
OrderedHashTable<JS::NonnullGCPtr<IntersectionObserver::IntersectionObserver>> m_intersection_observers;
// https://www.w3.org/TR/intersection-observer/#document-intersectionobservertaskqueued
// Each document has an IntersectionObserverTaskQueued flag which is initialized to false.
bool m_intersection_observer_task_queued { false };
LibWeb: Implement `loading=lazy` for `<img>` elements
2023-07-07 00:00:06 +01:00
// https://html.spec.whatwg.org/multipage/urls-and-fetching.html#lazy-load-intersection-observer
// Each Document has a lazy load intersection observer, initially set to null but can be set to an IntersectionObserver instance.
JS::GCPtr<IntersectionObserver::IntersectionObserver> m_lazy_load_intersection_observer;
LibWeb: Implement `<meta http-equiv="Refresh">` Required by Atlassian to continue to their authorization process. Also used by the SerenityOS FAQ redirect on the website, the Bootstrap documentation for going to older versions from the dropdown and likely several other sites.
2023-07-28 02:20:57 +01:00
// https://html.spec.whatwg.org/multipage/semantics.html#will-declaratively-refresh
// A Document object has an associated will declaratively refresh (a boolean). It is initially false.
bool m_will_declaratively_refresh { false };
RefPtr<Core::Timer> m_active_refresh_timer;
LibWeb: Don't parse inline style sheets during HTML fragment parsing Some websites (like Reddit) like to instantiate "components" by setting innerHTML to a huge chunk of stuff. Sometimes those huge chunks of stuff contain inline style sheets (i.e `<style>` elements). Before this change, we would end up parsing the CSS in those elements multiple times, because we had no way of knowing that we were within a fragment parser's temporary document. This patch avoids the extra CSS parsing work by adding adding a flag to Document that tells us it's being used by the fragment parser. Then, we simply avoid parsing CSS for style elements in such documents. The CSS then gets parsed immediately upon insertion into the proper DOM.
2023-08-09 15:10:00 +02:00
bool m_temporary_document_for_fragment_parsing { false };
LibWeb: Start fleshing out update document for history step application
2023-09-23 22:59:27 +02:00
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#latest-entry
JS::GCPtr<HTML::SessionHistoryEntry> m_latest_entry;
LibWeb: Forbid sharing image requests across documents This change addresses the bug where images unable to load when the reload button in the UI is clicked repeatedly. Before this fix, it was possible to use SharedImageRequests across multiple documents. However, when the document that initiated the request is gone, tasks scheduled on the event loop remain in the fetching state because the originating document is no longer active. Furthermore, another reason to prohibit the sharing of image requests across documents is that the "Origin" header in an image request is dependent on the document.
2023-10-17 16:52:16 +02:00
LibWeb+LibJS: Use JS::GCPtr for pointers to GC-allocated objects Fixes warnings found by LibJSGCVerifier
2023-12-11 12:23:04 +01:00
HashMap<AK::URL, JS::GCPtr<HTML::SharedImageRequest>> m_shared_image_requests;
LibWeb: Add a default DocumentTimeline object to DOM::Document
2023-11-04 08:38:46 -07:00
LibWeb: Store all timelines associated with a document on the document This will be required for propagating the current animation time to all relevant timelines, which each propagate that time to all of their relevant animations.
2023-11-04 08:43:10 -07:00
// https://www.w3.org/TR/web-animations-1/#timeline-associated-with-a-document
HashTable<JS::NonnullGCPtr<Animations::AnimationTimeline>> m_associated_animation_timelines;
LibWeb: Add a default DocumentTimeline object to DOM::Document
2023-11-04 08:38:46 -07:00
// https://www.w3.org/TR/web-animations-1/#document-default-document-timeline
JS::GCPtr<Animations::DocumentTimeline> m_default_timeline;
LibWeb: Add Document's pending animation event queue This is needed for Animation's update finished state procedure
2023-11-04 13:35:30 -07:00
// https://www.w3.org/TR/web-animations-1/#pending-animation-event-queue
Vector<PendingAnimationEvent> m_pending_animation_event_queue;
LibWeb: Support making a document active after it has completely loaded So far, we always call make_active() before update_readiness (Complete), but this will soon not be the case once we implement the spec document-loading algorithms. Co-authored-by: Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
2023-12-26 12:10:21 +00:00
bool m_needs_to_call_page_did_load { false };
LibWeb: Wait until new document becomes active before running scripts Fixes https://github.com/SerenityOS/serenity/issues/22485 With this change WebContent does not crash when `location.reload()` is invoked but `Navigable::reload()` still not working because of spec issue (https://github.com/whatwg/html/issues/9869) so we can't add a test yet.
2023-12-30 15:45:10 +01:00
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#scripts-may-run-for-the-newly-created-document
bool m_ready_to_run_scripts { false };
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 18:55:47 +02:00
};
LibWeb: Implement "NodeIterator pre-removing steps" These steps run when a node is about to be removed from its parent, and adjust the position of any live NodeIterators so that they don't point at a now-removed node. Note that while this commit implements what's in the DOM specification, the specification doesn't fully match what other browsers do. Spec bug: https://github.com/whatwg/dom/issues/907
2022-03-09 16:38:44 +01:00
LibWeb: Add fast_is<T>() for various types stood out in a profile
2023-03-10 21:16:18 +01:00
template<>
inline bool Node::fast_is<Document>() const { return is_document(); }
LibHTML: Add is<ElementType> and to<ElementType> helper functions These will help us write node-type-aware template functions.
2019-10-06 20:37:39 +02:00
}
Reference in a new issue Copy permalink