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

171 lines
6.1 KiB
C
Raw Normal View History

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
/*
* Copyright (c) 2025, Andreas Kling <andreas@ladybird.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/FlyString.h>
#include <AK/HashMap.h>
LibWeb: Narrow :has descendant invalidation fanout When a :has() mutation is known to come from a specific subtree, use that subtree as the mutation root while walking observed ancestors. Before dirtying an anchor and its non-subject descendants, check whether any cached :has() rule for that anchor can observe the changed subtree. This keeps unrelated descendant mutations from invalidating every rule that merely contains :has().
2026-04-27 05:06:35 -03:00
#include <AK/HashTable.h>
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
#include <AK/NonnullRefPtr.h>
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
#include <AK/Optional.h>
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
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
#include <AK/Vector.h>
#include <LibGC/Ptr.h>
#include <LibWeb/Animations/KeyframeEffect.h>
#include <LibWeb/CSS/CascadeOrigin.h>
LibWeb: Make `@counter-style` tree-scoped This was a pretty straightforward change of storing registered counter styles on the relevant `StyleScope`s and resolving by following the process to dereference a global tree-scoped name, the only things of note are: - We only define predefined counter styles (e.g. decimal) on the document's scope (since otherwise overrides in outer scopes would themselves be overriden). - When registering counter styles we don't have the full list of extendable styles so we defer fallback to "decimal" for undefined styles until `CounterStyle::from_counter_style_definition`.
2026-04-05 20:23:33 -03:00
#include <LibWeb/CSS/CounterStyle.h>
LibWeb: Narrow :has descendant invalidation fanout When a :has() mutation is known to come from a specific subtree, use that subtree as the mutation root while walking observed ancestors. Before dirtying an anchor and its non-subject descendants, check whether any cached :has() rule for that anchor can observe the changed subtree. This keeps unrelated descendant mutations from invalidating every rule that merely contains :has().
2026-04-27 05:06:35 -03:00
#include <LibWeb/CSS/InvalidationSet.h>
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
#include <LibWeb/CSS/Selector.h>
#include <LibWeb/CSS/StyleInvalidationData.h>
#include <LibWeb/Forward.h>
namespace Web::CSS {
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
class StyleScope;
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
struct MatchingRule {
GC::Ptr<CSSRule const> rule; // Either CSSStyleRule or CSSNestedDeclarations
GC::Ptr<CSSStyleSheet const> sheet;
Optional<FlyString> default_namespace;
Selector const& selector;
size_t style_sheet_index { 0 };
size_t rule_index { 0 };
u32 specificity { 0 };
CascadeOrigin cascade_origin;
bool contains_pseudo_element { false };
bool slotted { false };
LibWeb/CSS: Implement basic ::part() matching Matches elements with a `part` attribute, against their parent shadow host.
2025-12-09 10:42:53 -03:00
bool contains_part_pseudo_element { false };
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
// Helpers to deal with the fact that `rule` might be a CSSStyleRule or a CSSNestedDeclarations
CSSStyleProperties const& declaration() const;
SelectorList const& absolutized_selectors() const;
FlyString const& qualified_layer_name() const;
LibJS+LibWeb: Add missing GC marking visits This adds visit_edges(Cell::Visitor&) methods to various helper structs that contain GC pointers, and makes sure they are called from owning GC-heap-allocated objects as needed. These were found by our Clang plugin after expanding its capabilities. The added rules will be enforced by CI going forward.
2026-01-05 20:36:34 -03:00
void visit_edges(GC::Cell::Visitor&);
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
};
struct RuleCache {
HashMap<FlyString, Vector<MatchingRule>> rules_by_id;
HashMap<FlyString, Vector<MatchingRule>> rules_by_class;
HashMap<FlyString, Vector<MatchingRule>> rules_by_tag_name;
HashMap<FlyString, Vector<MatchingRule>, AK::ASCIICaseInsensitiveFlyStringTraits> rules_by_attribute_name;
Array<Vector<MatchingRule>, to_underlying(CSS::PseudoElement::KnownPseudoElementCount)> rules_by_pseudo_element;
Vector<MatchingRule> root_rules;
Vector<MatchingRule> slotted_rules;
LibWeb/CSS: Implement basic ::part() matching Matches elements with a `part` attribute, against their parent shadow host.
2025-12-09 10:42:53 -03:00
Vector<MatchingRule> part_rules;
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
Vector<MatchingRule> other_rules;
HashMap<FlyString, NonnullRefPtr<Animations::KeyframeEffect::KeyFrameSet>> rules_by_animation_keyframes;
void add_rule(MatchingRule const&, Optional<PseudoElement>, bool contains_root_pseudo_class);
void for_each_matching_rules(DOM::AbstractElement, Function<IterationDecision(Vector<MatchingRule> const&)> callback) const;
LibJS+LibWeb: Add missing GC marking visits This adds visit_edges(Cell::Visitor&) methods to various helper structs that contain GC pointers, and makes sure they are called from owning GC-heap-allocated objects as needed. These were found by our Clang plugin after expanding its capabilities. The added rules will be enforced by CI going forward.
2026-01-05 20:36:34 -03:00
void visit_edges(GC::Cell::Visitor&);
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
};
struct RuleCaches {
RuleCache main;
HashMap<FlyString, NonnullOwnPtr<RuleCache>> by_layer;
LibJS+LibWeb: Add missing GC marking visits This adds visit_edges(Cell::Visitor&) methods to various helper structs that contain GC pointers, and makes sure they are called from owning GC-heap-allocated objects as needed. These were found by our Clang plugin after expanding its capabilities. The added rules will be enforced by CI going forward.
2026-01-05 20:36:34 -03:00
void visit_edges(GC::Cell::Visitor&);
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
};
struct SelectorInsights {
bool has_has_selectors { false };
LibWeb: Skip useless sibling scans in generic :has() walks Track whether any :has() relative selector in a style scope uses a sibling combinator and let the generic ancestor walk consult that before scanning ancestor siblings. This keeps descendant-only :has() invalidations from walking unrelated siblings while preserving the existing behavior for selectors that use + or ~. Add counter-based test coverage so the reduced sibling scans stay visible through the invalidation counters.
2026-04-18 17:25:15 -03:00
bool has_has_selectors_with_relative_selector_that_has_sibling_combinator { false };
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
};
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
struct StyleCache : public RefCounted<StyleCache> {
static NonnullRefPtr<StyleCache> create();
static NonnullRefPtr<StyleCache> create_for_style_scope(StyleScope&);
Vector<FlyString> qualified_layer_names_in_order;
SelectorInsights selector_insights;
Array<OwnPtr<RuleCache>, to_underlying(PseudoClass::__Count)> pseudo_class_rule_cache;
StyleInvalidationData style_invalidation_data;
RuleCaches author_rule_cache;
RuleCaches user_rule_cache;
RuleCaches user_agent_rule_cache;
void visit_edges(GC::Cell::Visitor&);
};
LibWeb: Narrow :has descendant invalidation fanout When a :has() mutation is known to come from a specific subtree, use that subtree as the mutation root while walking observed ancestors. Before dirtying an anchor and its non-subject descendants, check whether any cached :has() rule for that anchor can observe the changed subtree. This keeps unrelated descendant mutations from invalidating every rule that merely contains :has().
2026-04-27 05:06:35 -03:00
struct PendingHasInvalidationMutationFeatures {
bool is_conservative { false };
HashTable<FlyString> tag_names;
HashTable<FlyString> ids;
HashTable<FlyString> class_names;
HashTable<FlyString> attribute_names;
};
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
class StyleScope {
public:
explicit StyleScope(GC::Ref<DOM::Node>);
DOM::Node& node() const { return m_node; }
DOM::Document& document() const;
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
RuleCaches const& author_rule_cache() const { return m_rule_cache->author_rule_cache; }
RuleCaches const& user_rule_cache() const { return m_rule_cache->user_rule_cache; }
RuleCaches const& user_agent_rule_cache() const { return m_rule_cache->user_agent_rule_cache; }
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
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
[[nodiscard]] bool has_valid_rule_cache() const { return m_rule_cache; }
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
void invalidate_rule_cache();
[[nodiscard]] RuleCache const& get_pseudo_class_rule_cache(PseudoClass) const;
LibWeb: Avoid template for `StyleScope::for_each_stylesheet` This only ever takes a `Function<void(CSS::CSSStyleSheet&)` so there is no need to use a template here.
2026-02-07 18:25:02 -03:00
void for_each_stylesheet(CascadeOrigin, Function<void(CSS::CSSStyleSheet&)> const&) const;
LibWeb: Rebuild counter style cache lazily Stop rebuilding the counter style cache from every style update. That made unrelated restyles pay the full counter-style cost even when no relevant stylesheet state had changed. Dirty the cache when stylesheet rule caches are invalidated and rebuild it on the first counter-style lookup instead. Also make cold cache rebuilds include user stylesheets. Add regression tests covering insertRule() and replaceSync() updates that should make newly defined counter styles take effect.
2026-04-05 06:20:32 -03:00
void build_user_style_sheet_if_needed();
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
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
void make_rule_cache_for_cascade_origin(CascadeOrigin, StyleCache&);
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
void build_rule_cache();
void build_rule_cache_if_needed() const;
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
void populate_rule_cache(StyleCache&);
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
static void collect_selector_insights(Selector const&, SelectorInsights&);
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
void build_qualified_layer_names_cache(StyleCache&);
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
[[nodiscard]] bool may_have_has_selectors() const;
[[nodiscard]] bool have_has_selectors() const;
LibWeb: Skip useless sibling scans in generic :has() walks Track whether any :has() relative selector in a style scope uses a sibling combinator and let the generic ancestor walk consult that before scanning ancestor siblings. This keeps descendant-only :has() invalidations from walking unrelated siblings while preserving the existing behavior for selectors that use + or ~. Add counter-based test coverage so the reduced sibling scans stay visible through the invalidation counters.
2026-04-18 17:25:15 -03:00
[[nodiscard]] bool may_have_has_selectors_with_relative_selector_that_has_sibling_combinator() const;
[[nodiscard]] bool have_has_selectors_with_relative_selector_that_has_sibling_combinator() const;
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
LibWeb: Pass callback as lvalue ref in `for_each_active_stylesheet` Taking the callback as an rvalue ref meant we couldn't use the same callback more than once
2026-02-07 18:20:32 -03:00
void for_each_active_css_style_sheet(Function<void(CSS::CSSStyleSheet&)> const& callback) const;
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
void invalidate_style_of_elements_affected_by_has();
LibWeb: Make `@counter-style` tree-scoped This was a pretty straightforward change of storing registered counter styles on the relevant `StyleScope`s and resolving by following the process to dereference a global tree-scoped name, the only things of note are: - We only define predefined counter styles (e.g. decimal) on the document's scope (since otherwise overrides in outer scopes would themselves be overriden). - When registering counter styles we don't have the full list of extendable styles so we defer fallback to "decimal" for undefined styles until `CounterStyle::from_counter_style_definition`.
2026-04-05 20:23:33 -03:00
void invalidate_counter_style_cache();
void build_counter_style_cache();
RefPtr<CSS::CounterStyle const> get_registered_counter_style(FlyString const& name) const;
LibWeb: Narrow :has descendant invalidation fanout When a :has() mutation is known to come from a specific subtree, use that subtree as the mutation root while walking observed ancestors. Before dirtying an anchor and its non-subject descendants, check whether any cached :has() rule for that anchor can observe the changed subtree. This keeps unrelated descendant mutations from invalidating every rule that merely contains :has().
2026-04-27 05:06:35 -03:00
void schedule_ancestors_style_invalidation_due_to_presence_of_has(GC::Ref<DOM::Node>);
void record_pending_has_invalidation_mutation_features(GC::Ref<DOM::Node>, GC::Ref<DOM::Node>, bool includes_descendants);
void record_pending_has_invalidation_mutation_features(GC::Ref<DOM::Node>, Vector<CSS::InvalidationSet::Property> const&);
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
LibWeb: Add helper method to dereference global tree-scoped references
2026-04-05 08:19:13 -03:00
template<typename T>
Optional<T> dereference_global_tree_scoped_reference(Function<Optional<T>(StyleScope const&)> const& callback) const;
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
void visit_edges(GC::Cell::Visitor&);
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
RefPtr<StyleCache> m_rule_cache;
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
GC::Ptr<CSSStyleSheet> m_user_style_sheet;
LibWeb: Use an `OrderedHashMap` for pending :has() invalidations Every DOM mutation that may affect a :has() selector enqueues an entry in StyleScope keyed by an ancestor node. The entries were previously stored in a Vector and linearly scanned on every insert to deduplicate by node. We now use an OrderedHashMap instead, eliminating the quadratic deduplication.
2026-04-29 03:03:01 -03:00
OrderedHashMap<GC::Ref<DOM::Node>, PendingHasInvalidationMutationFeatures> m_pending_has_invalidations;
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
LibWeb: Make `@counter-style` tree-scoped This was a pretty straightforward change of storing registered counter styles on the relevant `StyleScope`s and resolving by following the process to dereference a global tree-scoped name, the only things of note are: - We only define predefined counter styles (e.g. decimal) on the document's scope (since otherwise overrides in outer scopes would themselves be overriden). - When registering counter styles we don't have the full list of extendable styles so we defer fallback to "decimal" for undefined styles until `CounterStyle::from_counter_style_definition`.
2026-04-05 20:23:33 -03:00
bool m_needs_counter_style_cache_update : 1 { true };
bool m_is_doing_counter_style_cache_update : 1 { false };
HashMap<FlyString, NonnullRefPtr<CSS::CounterStyle const>> m_registered_counter_styles;
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
GC::Ref<DOM::Node> m_node;
};
}
Reference in a new issue Copy permalink