dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWeb/DOM/AbstractElement.h

92 lines
3.2 KiB
C
Raw Permalink Normal View History

LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
/*
LibWeb/CSS: Pass AbstractElement to SelectorEngine::matches ...instead of separate Element and PseudoElement arguments. As noted, AbstractElement's constness is weird currently, but that's a tangent I don't want to go on right now.
2026-04-01 10:19:00 -03:00
* Copyright (c) 2025-2026, Sam Atkins <sam@ladybird.org>
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibGC/Cell.h>
LibWeb/DOM: Reduce AbstractElement.h's includes This doesn't need all of Selector.h and its various includes, it just needs the PseudoElement enum. StringStyleValue.h was transitively including ComponentValue.h through this, so it now includes it directly.
2025-09-09 09:37:30 -03:00
#include <LibWeb/CSS/PseudoElement.h>
LibWeb/DOM: Stop including Element.h from AbstractElement.h We only need the forward declaration here, and this will let us include AbstractElement from Element.
2025-06-17 10:07:50 -03:00
#include <LibWeb/Forward.h>
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
namespace Web::DOM {
LibWeb/DOM: Rename ElementReference to AbstractElement This isn't some kind of identifier, it's a handle on an actual Element or PseudoElement.
2025-06-18 06:19:56 -03:00
// Either an Element or a PseudoElement
LibWeb/CSS: Pass AbstractElement to SelectorEngine::matches ...instead of separate Element and PseudoElement arguments. As noted, AbstractElement's constness is weird currently, but that's a tangent I don't want to go on right now.
2026-04-01 10:19:00 -03:00
// FIXME: Figure out const-correctness for the Element.
LibWeb/DOM: Expose AbstractElement outside of LibWeb This ends up used by the WebContent service's ConnectionFromClient in a later commit.
2025-09-07 10:27:04 -03:00
class WEB_API AbstractElement {
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
public:
LibWeb/DOM: Rename ElementReference to AbstractElement This isn't some kind of identifier, it's a handle on an actual Element or PseudoElement.
2025-06-18 06:19:56 -03:00
AbstractElement(GC::Ref<Element>, Optional<CSS::PseudoElement> = {});
LibWeb/CSS: Pass AbstractElement to SelectorEngine::matches ...instead of separate Element and PseudoElement arguments. As noted, AbstractElement's constness is weird currently, but that's a tangent I don't want to go on right now.
2026-04-01 10:19:00 -03:00
AbstractElement(Element const&, Optional<CSS::PseudoElement> = {});
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
LibWeb/DOM: Add document getter to AbstractElement
2025-07-10 08:19:28 -03:00
Document& document() const;
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
Element& element() { return m_element; }
Element const& element() const { return m_element; }
LibWeb/CSS: Move and rename PseudoElement types to prep for code gen The upcoming generated types will match those for pseudo-classes: A PseudoElementSelector type, that then holds a PseudoElement enum defining what it is. That enum will be at the top level in the Web::CSS namespace. In order to keep the diffs clearer, this commit renames and moves the types, and then a following one will replace the handwritten enum with a generated one.
2025-03-20 13:56:46 -03:00
Optional<CSS::PseudoElement> pseudo_element() const { return m_pseudo_element; }
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
LibWeb: Make layout nodes refcounted Move the layout tree from GC allocation to refcounted ownership so removed layout and paint subtrees are destroyed synchronously instead of waiting for the next GC sweep. This dramatically reduces GC memory usage peaks after layout tree churn and makes it easier for memory use to fall back after large document updates. Update layout factories, tree traversal, SVG layout node creation, paintable back-pointers, and pseudo-element layout links to use RefPtr ownership. Make display: contents follow the same shape as Blink and WebKit: the element itself does not create a layout node, and its children are flattened into the nearest layout parent. Wrap direct non-whitespace text in an anonymous inline node when the boxless element contributes inherited style to that text. Use an internal inline wrapper for display: contents pseudo-elements so generated content can still participate in layout, painting, hit testing, and pseudo-element queries. Keep CSSOM reporting the computed display value from the pseudo style, not the internal wrapper. Remove the retained out-of-tree layout node list and its testing hook, since the flattened model does not need a side owner for boxless elements. Add coverage for inherited text style, dynamic insertion order, pseudo-element hit testing, and computed style queries.
2026-06-07 12:50:33 -03:00
Layout::NodeWithStyle* layout_node();
Layout::NodeWithStyle const* layout_node() const { return const_cast<AbstractElement*>(this)->layout_node(); }
LibWeb: Support counter-* properties on pseudo-elements There are multiple things happening here which are interconnected: - We now use AbstractElement to refer to the source of a counter, which means we also need to pass that around to compute `content`. - Give AbstractElement new helper methods that are needed by CountersSet, so it doesn't have to care whether it's dealing with a true Element or PseudoElement. - The CountersSet algorithms now walk the layout tree instead of DOM tree, so TreeBuilder needs to wait until the layout node exists before it resolves counters for it. - Resolve counters when creating a pseudo-element's layout node. We awkwardly compute the `content` value up to twice: Once to figure out what kind of node we need to make, and then if it's a string, we do so again after counters are resolved so we can get the true value of any `counter()` functions. This will need adjusting in the future but it works for now.
2025-06-17 12:33:23 -03:00
LibWeb: Make layout nodes refcounted Move the layout tree from GC allocation to refcounted ownership so removed layout and paint subtrees are destroyed synchronously instead of waiting for the next GC sweep. This dramatically reduces GC memory usage peaks after layout tree churn and makes it easier for memory use to fall back after large document updates. Update layout factories, tree traversal, SVG layout node creation, paintable back-pointers, and pseudo-element layout links to use RefPtr ownership. Make display: contents follow the same shape as Blink and WebKit: the element itself does not create a layout node, and its children are flattened into the nearest layout parent. Wrap direct non-whitespace text in an anonymous inline node when the boxless element contributes inherited style to that text. Use an internal inline wrapper for display: contents pseudo-elements so generated content can still participate in layout, painting, hit testing, and pseudo-element queries. Keep CSSOM reporting the computed display value from the pseudo style, not the internal wrapper. Remove the retained out-of-tree layout node list and its testing hook, since the flattened model does not need a side owner for boxless elements. Add coverage for inherited text style, dynamic insertion order, pseudo-element hit testing, and computed style queries.
2026-06-07 12:50:33 -03:00
Layout::NodeWithStyle* unsafe_layout_node();
Layout::NodeWithStyle const* unsafe_layout_node() const { return const_cast<AbstractElement*>(this)->unsafe_layout_node(); }
LibWeb: Use unsafe layout/paintable accessors where appropriate Add unsafe_layout_node(), unsafe_paintable(), and unsafe_paintable_box() accessors that skip layout-staleness verification. These are for use in contexts where accessing layout/paintable data is legitimate despite layout not being up to date: tree construction, style recalculation, painting, animation interpolation, DOM mutation, and invalidation propagation. Also add wrapper APIs on Node to centralize common patterns: - set_needs_display() wraps if (unsafe_paintable()) ...set_needs_display - set_needs_paint_only_properties_update() wraps similar - set_needs_layout_update() wraps if (unsafe_layout_node()) ... And add Document::layout_is_up_to_date() which checks whether layout tree update flags are all clear.
2026-02-26 07:57:29 -03:00
LibWeb: Pass `AbstractElement` in `ComputationContext` Passing the `AbstractElement` rather than the `TreeCountingFunctionResolutionContext` allows us to only compute the resolution context when necessary (i.e. when we actually need to resolve a tree counting function)
2025-10-21 08:06:38 -03:00
struct TreeCountingFunctionResolutionContext {
size_t sibling_count;
size_t sibling_index;
};
TreeCountingFunctionResolutionContext tree_counting_function_resolution_context() const;
LibWeb: Compute and propagate tree-counting function resolution context Tree counting functions should be resolved at style computation time - to do this we will need to know the element's sibling count and index. This commit computes that information and propagates it to the various `StyleValue::to_computed_value` methods.
2025-09-30 00:45:37 -03:00
LibWeb/DOM: Rename ElementReference to AbstractElement This isn't some kind of identifier, it's a handle on an actual Element or PseudoElement.
2025-06-18 06:19:56 -03:00
GC::Ptr<Element const> parent_element() const;
LibWeb: Return `AbstractElement` from `element_to_inherit_style_from` No functional changes.
2025-08-21 01:38:17 -03:00
Optional<AbstractElement> element_to_inherit_style_from() const;
LibWeb: Support counter-* properties on pseudo-elements There are multiple things happening here which are interconnected: - We now use AbstractElement to refer to the source of a counter, which means we also need to pass that around to compute `content`. - Give AbstractElement new helper methods that are needed by CountersSet, so it doesn't have to care whether it's dealing with a true Element or PseudoElement. - The CountersSet algorithms now walk the layout tree instead of DOM tree, so TreeBuilder needs to wait until the layout node exists before it resolves counters for it. - Resolve counters when creating a pseudo-element's layout node. We awkwardly compute the `content` value up to twice: Once to figure out what kind of node we need to make, and then if it's a string, we do so again after counters are resolved so we can get the true value of any `counter()` functions. This will need adjusting in the future but it works for now.
2025-06-17 12:33:23 -03:00
Optional<AbstractElement> previous_in_tree_order() { return walk_layout_tree(WalkMethod::Previous); }
Optional<AbstractElement> previous_sibling_in_tree_order() { return walk_layout_tree(WalkMethod::PreviousSibling); }
bool is_before(AbstractElement const&) const;
LibWeb: Better CSS inheritance for nodes that represent a pseudo-element When we compute style for elements inside a UA-internal shadow tree that represent a pseudo-element (e.g ::placeholder), we actually run the StyleComputer machinery for (host element :: pseudo-element). While that lets us match the correct selectors, it was incorrectly applying CSS inheritance, since we'd also then inherit from whatever was above the host element in the tree. This patch fixes the issue by introducing an inheritance override in AbstractElement and then using that to force inheritance from whatever is actually directly above in the DOM for these elements instead of jumping all the way up past the host. This fixes an issue where `text-align: center` on input type=text elements would render the main text centered but placeholder text was still left-aligned.
2025-10-20 06:21:55 -03:00
void set_inheritance_override(GC::Ref<Element> element) { m_inheritance_override = element; }
LibWeb: Make computed style data refcounted Move ComputedProperties and CascadedProperties out of the GC. They no longer contain strong references to GC-managed data. Keep computed styles alive from DOM elements and animation updates with RefPtr. Pass style into layout constructors by reference, since layout only copies the values it needs while building nodes. Use GC::Weak for cascade source links, so entries no longer keep the style declaration or shadow root alive.
2026-06-06 09:03:41 -03:00
CSS::ComputedProperties const* computed_properties() const;
LibWeb: Apply "element-reference" pseudo inline styles correctly Previously we applied them ad-hoc when computing the style for the referenced element but we now apply it as part of the cascade. This fixes a couple bugs: - Computing the style for the pseudo-element (rather than the referenced element itself) as we do in the case we don't have a layout node in `get_direct_property` now includes the inline style. - Inline style is applied according to the cascade (i.e. it can be overriden by non-inline `!important` styles). - Properties go through the computation process.
2026-05-16 07:47:04 -03:00
GC::Ptr<CSS::CSSStyleProperties const> inline_style() const;
LibWeb/DOM: Rename ElementReference to AbstractElement This isn't some kind of identifier, it's a handle on an actual Element or PseudoElement.
2025-06-18 06:19:56 -03:00
LibWeb: Use structural sharing for CSS custom properties Replace per-element OrderedHashMap storage for custom properties with a RefCounted chain (CustomPropertyData) that enables structural sharing. Each chain node stores only the properties declared directly on its element, with a parent pointer to the inherited chain. Elements that don't override any custom properties share the parent's data directly (just a RefPtr copy). During cascade, only entries that actually differ from the parent are stored in own_values - the rest are inherited through the chain. During var() resolution, resolved values are compared against the parent's and matching entries are dropped, enabling further sharing. The chain uses a depth limit (max 32) with flattening, plus absorption of small parent nodes (threshold 8) to keep lookups fast. This reduces custom property memory from ~79 MB to ~5.7 MB on cloudflare.com.
2026-02-13 06:19:02 -03:00
void set_custom_property_data(RefPtr<CSS::CustomPropertyData const>);
[[nodiscard]] RefPtr<CSS::CustomPropertyData const> custom_property_data() const;
LibWeb: Store custom property names as UTF-16 Move PropertyNameAndID, custom property data, registered custom properties, and Typed OM associated property names to Utf16FlyString. This removes the FlyString storage boundary from CSS property-name handling and lets CSSStyleProperties keep the name it receives from CSSOM instead of converting it back to UTF-8.
2026-06-08 15:31:27 -03:00
RefPtr<CSS::StyleValue const> get_custom_property(Utf16FlyString const& name) const;
LibWeb/DOM: Add custom-property helpers to AbstractElement
2025-06-19 11:03:50 -03:00
LibWeb: Support counter-* properties on pseudo-elements There are multiple things happening here which are interconnected: - We now use AbstractElement to refer to the source of a counter, which means we also need to pass that around to compute `content`. - Give AbstractElement new helper methods that are needed by CountersSet, so it doesn't have to care whether it's dealing with a true Element or PseudoElement. - The CountersSet algorithms now walk the layout tree instead of DOM tree, so TreeBuilder needs to wait until the layout node exists before it resolves counters for it. - Resolve counters when creating a pseudo-element's layout node. We awkwardly compute the `content` value up to twice: Once to figure out what kind of node we need to make, and then if it's a string, we do so again after counters are resolved so we can get the true value of any `counter()` functions. This will need adjusting in the future but it works for now.
2025-06-17 12:33:23 -03:00
bool has_non_empty_counters_set() const;
Optional<CSS::CountersSet const&> counters_set() const;
LibWeb/DOM: Rename ElementReference to AbstractElement This isn't some kind of identifier, it's a handle on an actual Element or PseudoElement.
2025-06-18 06:19:56 -03:00
CSS::CountersSet& ensure_counters_set();
void set_counters_set(OwnPtr<CSS::CountersSet>&&);
LibWeb: Store CSS defined animations as `CSSAnimation` In a later commit we will be calling `CSSAnimation` specific methods on these and this saves us casting to a `CSSAnimation` every time
2026-02-10 01:14:10 -03:00
HashMap<FlyString, GC::Ref<CSS::CSSAnimation>>* css_defined_animations() const;
LibWeb/DOM: Add animation helpers to AbstractElement
2025-12-02 08:03:07 -03:00
void set_has_css_defined_animations();
LibWeb/DOM: Rename ElementReference to AbstractElement This isn't some kind of identifier, it's a handle on an actual Element or PseudoElement.
2025-06-18 06:19:56 -03:00
void visit(GC::Cell::Visitor& visitor) const;
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
LibWeb: Support counter-* properties on pseudo-elements There are multiple things happening here which are interconnected: - We now use AbstractElement to refer to the source of a counter, which means we also need to pass that around to compute `content`. - Give AbstractElement new helper methods that are needed by CountersSet, so it doesn't have to care whether it's dealing with a true Element or PseudoElement. - The CountersSet algorithms now walk the layout tree instead of DOM tree, so TreeBuilder needs to wait until the layout node exists before it resolves counters for it. - Resolve counters when creating a pseudo-element's layout node. We awkwardly compute the `content` value up to twice: Once to figure out what kind of node we need to make, and then if it's a string, we do so again after counters are resolved so we can get the true value of any `counter()` functions. This will need adjusting in the future but it works for now.
2025-06-17 12:33:23 -03:00
String debug_description() const;
bool operator==(AbstractElement const&) const = default;
LibWeb: Add StyleScope to keep style caches per Document/ShadowRoot Before this change, we've been maintaining various StyleComputer caches at the document level. This made sense for old-school documents without shadow trees, since all the style information was document-wide anyway. However, documents with many shadow trees ended up suffering since any time you mutated a style sheet inside a shadow tree, *all* style caches for the entire document would get invalidated. This was particularly expensive on Reddit, which has tons of shadow trees with their own style elements. Every time we'd create one of their custom elements, we'd invalidate the document-level "rule cache" and have to rebuild it, taking about ~60ms each time (ouch). This commit introduces a new object called StyleScope. Every Document and ShadowRoot has its own StyleScope. Rule caches etc are moved from StyleComputer to StyleScope. Rule cache invalidation now happens at StyleScope level. As an example, rule cache rebuilds now take ~1ms on Reddit instead of ~60ms. This is largely a mechanical change, moving things around, but there's one key detail to be aware of: due to the :host selector, which works across the shadow DOM boundary and reaches from inside a shadow tree out into the light tree, there are various places where we have to check both the shadow tree's StyleScope *and* the document-level StyleScope in order to get all rules that may apply.
2025-11-13 15:08:08 -03:00
CSS::StyleScope const& style_scope() const;
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
private:
LibWeb: Support counter-* properties on pseudo-elements There are multiple things happening here which are interconnected: - We now use AbstractElement to refer to the source of a counter, which means we also need to pass that around to compute `content`. - Give AbstractElement new helper methods that are needed by CountersSet, so it doesn't have to care whether it's dealing with a true Element or PseudoElement. - The CountersSet algorithms now walk the layout tree instead of DOM tree, so TreeBuilder needs to wait until the layout node exists before it resolves counters for it. - Resolve counters when creating a pseudo-element's layout node. We awkwardly compute the `content` value up to twice: Once to figure out what kind of node we need to make, and then if it's a string, we do so again after counters are resolved so we can get the true value of any `counter()` functions. This will need adjusting in the future but it works for now.
2025-06-17 12:33:23 -03:00
enum class WalkMethod : u8 {
Previous,
PreviousSibling,
};
Optional<AbstractElement> walk_layout_tree(WalkMethod);
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
GC::Ref<Element> m_element;
LibWeb/CSS: Move and rename PseudoElement types to prep for code gen The upcoming generated types will match those for pseudo-classes: A PseudoElementSelector type, that then holds a PseudoElement enum defining what it is. That enum will be at the top level in the Web::CSS namespace. In order to keep the diffs clearer, this commit renames and moves the types, and then a following one will replace the handwritten enum with a generated one.
2025-03-20 13:56:46 -03:00
Optional<CSS::PseudoElement> m_pseudo_element;
LibWeb: Better CSS inheritance for nodes that represent a pseudo-element When we compute style for elements inside a UA-internal shadow tree that represent a pseudo-element (e.g ::placeholder), we actually run the StyleComputer machinery for (host element :: pseudo-element). While that lets us match the correct selectors, it was incorrectly applying CSS inheritance, since we'd also then inherit from whatever was above the host element in the tree. This patch fixes the issue by introducing an inheritance override in AbstractElement and then using that to force inheritance from whatever is actually directly above in the DOM for these elements instead of jumping all the way up past the host. This fixes an issue where `text-align: center` on input type=text elements would render the main text centered but placeholder text was still left-aligned.
2025-10-20 06:21:55 -03:00
GC::Ptr<Element> m_inheritance_override;
LibWeb/DOM: Introduce an ElementReference type We have the "Element, but also maybe a pseudo-element of it" concept in a lot of places, so let's wrap it up in a single type to make it easier to deal with.
2025-03-17 13:00:12 -03:00
};
}
LibWeb: Apply all animations and transitions before invalidating style This fixes an issue where only the last KeyframeEffect applied to an element would actually have an effect on the computed properties. It was particularly noticeable when animating a shorthand property like border-width, since only one of the border edges would have its width actually animate. By deferring the invalidation until all animations have been processed, we also reduce the amount of work that gets done on pages with many animations/transitions per element. Discord is very fond of this for example.
2025-07-18 06:56:00 -03:00
template<>
struct AK::Traits<Web::DOM::AbstractElement> : public DefaultTraits<Web::DOM::AbstractElement> {
static unsigned hash(Web::DOM::AbstractElement const& key)
{
return pair_int_hash(ptr_hash(&key.element()), key.pseudo_element().has_value() ? to_underlying(key.pseudo_element().value()) : -1);
}
};
Reference in a new issue Copy permalink