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.

Author: awesomekling

Libraries/LibWeb/CMakeLists.txt

@@ -215,6 +215,7 @@ set(SOURCES
     CSS/StyleProperty.cpp
     CSS/StylePropertyMapReadOnly.cpp
     CSS/StylePropertyMap.cpp
+    CSS/StyleScope.cpp
     CSS/StyleSheet.cpp
     CSS/StyleSheetIdentifier.cpp
     CSS/StyleSheetList.cpp

Libraries/LibWeb/CSS/CSSLayerBlockRule.cpp

@@ -69,7 +69,7 @@ String CSSLayerBlockRule::serialized() const
     return builder.to_string_without_validation();
 }
 
-FlyString CSSLayerBlockRule::internal_qualified_name(Badge<StyleComputer>) const
+FlyString CSSLayerBlockRule::internal_qualified_name(Badge<StyleScope>) const
 {
     auto const& parent_name = parent_layer_internal_qualified_name();
     if (parent_name.is_empty())

Libraries/LibWeb/CSS/CSSLayerBlockRule.h

@@ -24,7 +24,7 @@ class CSSLayerBlockRule final : public CSSGroupingRule {
 
     FlyString const& name() const { return m_name; }
     FlyString const& internal_name() const { return m_name_internal; }
-    FlyString internal_qualified_name(Badge<StyleComputer>) const;
+    FlyString internal_qualified_name(Badge<StyleScope>) const;
 
 private:
     CSSLayerBlockRule(JS::Realm&, FlyString name, CSSRuleList&);

Libraries/LibWeb/CSS/CSSLayerStatementRule.cpp

@@ -40,7 +40,7 @@ String CSSLayerStatementRule::serialized() const
     return builder.to_string_without_validation();
 }
 
-Vector<FlyString> CSSLayerStatementRule::internal_qualified_name_list(Badge<StyleComputer>) const
+Vector<FlyString> CSSLayerStatementRule::internal_qualified_name_list(Badge<StyleScope>) const
 {
     Vector<FlyString> qualified_layer_names;
 

Libraries/LibWeb/CSS/CSSLayerStatementRule.h

@@ -22,7 +22,7 @@ class CSSLayerStatementRule final : public CSSRule {
 
     // FIXME: Should be FrozenArray
     ReadonlySpan<FlyString> name_list() const { return m_name_list; }
-    Vector<FlyString> internal_qualified_name_list(Badge<StyleComputer>) const;
+    Vector<FlyString> internal_qualified_name_list(Badge<StyleScope>) const;
 
 private:
     CSSLayerStatementRule(JS::Realm&, Vector<FlyString> name_list);

Libraries/LibWeb/CSS/CSSStyleSheet.cpp

@@ -353,7 +353,8 @@ void CSSStyleSheet::invalidate_owners(DOM::StyleInvalidationReason reason)
     m_did_match = {};
     for (auto& document_or_shadow_root : m_owning_documents_or_shadow_roots) {
         document_or_shadow_root->invalidate_style(reason);
-        document_or_shadow_root->document().style_computer().invalidate_rule_cache();
+        auto& style_scope = document_or_shadow_root->is_shadow_root() ? as<DOM::ShadowRoot>(*document_or_shadow_root).style_scope() : document_or_shadow_root->document().style_scope();
+        style_scope.invalidate_rule_cache();
     }
 }
 

Libraries/LibWeb/CSS/StyleComputer.cpp

@@ -20,6 +20,7 @@
 #include <LibWeb/CSS/CascadedProperties.h>
 #include <LibWeb/CSS/Selector.h>
 #include <LibWeb/CSS/StyleInvalidationData.h>
+#include <LibWeb/CSS/StyleScope.h>
 #include <LibWeb/Export.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/Loader/ResourceLoader.h>
@@ -75,26 +76,6 @@ class CountingBloomFilter {
     CounterType m_buckets[bucket_count];
 };
 
-struct MatchingRule {
-    GC::Ptr<DOM::ShadowRoot const> shadow_root;
-    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 };
-
-    // 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;
-};
-
 struct FontFaceKey;
 
 struct OwnFontFaceKey {
@@ -120,22 +101,6 @@ struct FontMatchingAlgorithmCacheKey {
     [[nodiscard]] bool operator==(FontMatchingAlgorithmCacheKey const& other) const = default;
 };
 
-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;
-    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;
-};
-
 class FontLoader;
 
 class WEB_API StyleComputer final : public GC::Cell {
@@ -164,15 +129,10 @@ class WEB_API StyleComputer final : public GC::Cell {
     [[nodiscard]] GC::Ref<ComputedProperties> compute_style(DOM::AbstractElement, Optional<bool&> did_change_custom_properties = {}) const;
     [[nodiscard]] GC::Ptr<ComputedProperties> compute_pseudo_element_style_if_needed(DOM::AbstractElement, Optional<bool&> did_change_custom_properties) const;
 
-    [[nodiscard]] RuleCache const& get_pseudo_class_rule_cache(PseudoClass) const;
-
     [[nodiscard]] Vector<MatchingRule const*> collect_matching_rules(DOM::AbstractElement, CascadeOrigin, PseudoClassBitmap& attempted_pseudo_class_matches, Optional<FlyString const> qualified_layer_name = {}) const;
 
-    InvalidationSet invalidation_set_for_properties(Vector<InvalidationSet::Property> const&) const;
-    bool invalidation_property_used_in_has_selector(InvalidationSet::Property const&) const;
-
-    [[nodiscard]] bool has_valid_rule_cache() const { return m_author_rule_cache; }
-    void invalidate_rule_cache();
+    InvalidationSet invalidation_set_for_properties(Vector<InvalidationSet::Property> const&, StyleScope const&) const;
+    bool invalidation_property_used_in_has_selector(InvalidationSet::Property const&, StyleScope const&) const;
 
     Gfx::Font const& initial_font() const;
 
@@ -193,9 +153,6 @@ class WEB_API StyleComputer final : public GC::Cell {
 
     void collect_animation_into(DOM::AbstractElement, GC::Ref<Animations::KeyframeEffect> animation, ComputedProperties&) const;
 
-    [[nodiscard]] bool may_have_has_selectors() const;
-    [[nodiscard]] bool have_has_selectors() const;
-
     size_t number_of_css_font_faces_with_loading_in_progress() const;
 
     [[nodiscard]] GC::Ref<ComputedProperties> compute_properties(DOM::AbstractElement, CascadedProperties&) const;
@@ -242,10 +199,10 @@ class WEB_API StyleComputer final : public GC::Cell {
         Vector<LayerMatchingRules> author_rules;
     };
 
-    [[nodiscard]] MatchingRuleSet build_matching_rule_set(DOM::AbstractElement, PseudoClassBitmap& attempted_pseudo_class_matches, bool& did_match_any_pseudo_element_rules, ComputeStyleMode) const;
+    [[nodiscard]] MatchingRuleSet build_matching_rule_set(DOM::AbstractElement, PseudoClassBitmap& attempted_pseudo_class_matches, bool& did_match_any_pseudo_element_rules, ComputeStyleMode, StyleScope const&) const;
 
     LogicalAliasMappingContext compute_logical_alias_mapping_context(DOM::AbstractElement, ComputeStyleMode, MatchingRuleSet const&) const;
-    [[nodiscard]] GC::Ptr<ComputedProperties> compute_style_impl(DOM::AbstractElement, ComputeStyleMode, Optional<bool&> did_change_custom_properties) const;
+    [[nodiscard]] GC::Ptr<ComputedProperties> compute_style_impl(DOM::AbstractElement, ComputeStyleMode, Optional<bool&> did_change_custom_properties, StyleScope const&) const;
     [[nodiscard]] GC::Ref<CascadedProperties> compute_cascaded_values(DOM::AbstractElement, bool did_match_any_pseudo_element_rules, ComputeStyleMode, MatchingRuleSet const&, Optional<LogicalAliasMappingContext>, ReadonlySpan<PropertyID> properties_to_cascade) const;
     static RefPtr<Gfx::FontCascadeList const> find_matching_font_weight_ascending(Vector<MatchingFontCandidate> const& candidates, int target_weight, float font_size_in_pt, Gfx::FontVariationSettings const& variations, bool inclusive);
     static RefPtr<Gfx::FontCascadeList const> find_matching_font_weight_descending(Vector<MatchingFontCandidate> const& candidates, int target_weight, float font_size_in_pt, Gfx::FontVariationSettings const& variations, bool inclusive);
@@ -257,16 +214,10 @@ class WEB_API StyleComputer final : public GC::Cell {
     void resolve_effective_overflow_values(ComputedProperties&) const;
     void transform_box_type_if_needed(ComputedProperties&, DOM::AbstractElement) const;
 
-    template<typename Callback>
-    void for_each_stylesheet(CascadeOrigin, Callback) const;
-
     [[nodiscard]] CSSPixelRect viewport_rect() const { return m_viewport_rect; }
 
     [[nodiscard]] Length::FontMetrics calculate_root_element_font_metrics(ComputedProperties const&) const;
 
-    Vector<FlyString> m_qualified_layer_names_in_order;
-    void build_qualified_layer_names_cache();
-
     void cascade_declarations(
         CascadedProperties&,
         DOM::AbstractElement,
@@ -277,39 +228,10 @@ class WEB_API StyleComputer final : public GC::Cell {
         Optional<LogicalAliasMappingContext>,
         ReadonlySpan<PropertyID> properties_to_cascade) const;
 
-    void build_rule_cache();
-    void build_rule_cache_if_needed() const;
-
     GC::Ref<DOM::Document> m_document;
 
-    struct SelectorInsights {
-        bool has_has_selectors { false };
-    };
-
-    struct RuleCaches {
-        RuleCache main;
-        HashMap<FlyString, NonnullOwnPtr<RuleCache>> by_layer;
-    };
-
-    struct RuleCachesForDocumentAndShadowRoots {
-        RuleCaches for_document;
-        HashMap<GC::Ref<DOM::ShadowRoot const>, NonnullOwnPtr<RuleCaches>> for_shadow_roots;
-    };
-
-    void make_rule_cache_for_cascade_origin(CascadeOrigin, SelectorInsights&);
-
     [[nodiscard]] RuleCache const* rule_cache_for_cascade_origin(CascadeOrigin, Optional<FlyString const> qualified_layer_name, GC::Ptr<DOM::ShadowRoot const>) const;
 
-    static void collect_selector_insights(Selector const&, SelectorInsights&);
-
-    OwnPtr<SelectorInsights> m_selector_insights;
-    Array<OwnPtr<RuleCache>, to_underlying(PseudoClass::__Count)> m_pseudo_class_rule_cache;
-    OwnPtr<StyleInvalidationData> m_style_invalidation_data;
-    OwnPtr<RuleCachesForDocumentAndShadowRoots> m_author_rule_cache;
-    OwnPtr<RuleCachesForDocumentAndShadowRoots> m_user_rule_cache;
-    OwnPtr<RuleCachesForDocumentAndShadowRoots> m_user_agent_rule_cache;
-    GC::Ptr<CSSStyleSheet> m_user_style_sheet;
-
     using FontLoaderList = Vector<GC::Ref<FontLoader>>;
     HashMap<OwnFontFaceKey, FontLoaderList> m_loaded_fonts;