mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2026-06-28 12:10:28 +00:00
bae4434780
Track last-child and backward positional selector dependencies separately on parent nodes. A last-child or only-child selector can only change the element at the trailing edge, so insertions and removals can invalidate that element directly instead of walking every previous sibling. Keep the previous-sibling walk for selectors such as nth-last-child and last-of-type, where every previous element's from-end position may change.
178 lines
8.8 KiB
C++
178 lines
8.8 KiB
C++
/*
|
|
* Copyright (c) 2026-present, the Ladybird developers
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <LibWeb/CSS/Invalidation/HasMutationInvalidator.h>
|
|
#include <LibWeb/CSS/Invalidation/StructuralMutationInvalidator.h>
|
|
#include <LibWeb/DOM/Document.h>
|
|
#include <LibWeb/DOM/Element.h>
|
|
#include <LibWeb/DOM/Node.h>
|
|
#include <LibWeb/DOM/ParentNode.h>
|
|
#include <LibWeb/DOM/ShadowRoot.h>
|
|
|
|
namespace Web::CSS::Invalidation {
|
|
|
|
static bool element_is_affected_by_same_parent_move(DOM::Element const& element)
|
|
{
|
|
return element.affected_by_forward_structural_changes()
|
|
|| element.affected_by_backward_structural_changes()
|
|
|| element.affected_by_has_pseudo_class_in_subject_position()
|
|
|| element.affected_by_has_pseudo_class_in_non_subject_position()
|
|
|| element.affected_by_has_pseudo_class_with_relative_selector_that_has_sibling_combinator();
|
|
}
|
|
|
|
static void mark_sibling_for_style_update(DOM::Element& element)
|
|
{
|
|
auto mark_descendant_shadow_roots_for_style_update = [](DOM::Element& element) {
|
|
element.for_each_shadow_including_inclusive_descendant([](DOM::Node& inclusive_descendant) {
|
|
auto* descendant_element = as_if<DOM::Element>(inclusive_descendant);
|
|
if (!descendant_element)
|
|
return TraversalDecision::Continue;
|
|
auto shadow_root = descendant_element->shadow_root();
|
|
if (!shadow_root)
|
|
return TraversalDecision::Continue;
|
|
shadow_root->set_entire_subtree_needs_style_update(true);
|
|
shadow_root->set_needs_style_update(true);
|
|
return TraversalDecision::Continue;
|
|
});
|
|
};
|
|
|
|
// The structural change might flip whether `element` matches selectors like :nth-child or `~`/`+`, but those
|
|
// pseudo-classes and combinators only affect `element` itself unless some descendant selector also depends on
|
|
// `element`'s position. Mark just `element` when descendants don't observe its position; mark the entire
|
|
// subtree only when they do.
|
|
if (element.affected_by_structural_pseudo_class_in_non_subject_position() || element.affected_by_sibling_combinator_in_non_subject_position()) {
|
|
element.set_entire_subtree_needs_style_update(true);
|
|
} else {
|
|
element.set_needs_style_update(true);
|
|
mark_descendant_shadow_roots_for_style_update(element);
|
|
}
|
|
}
|
|
|
|
void invalidate_structurally_affected_siblings(DOM::Node& node, DOM::StyleInvalidationReason reason)
|
|
{
|
|
auto is_insertion_or_removal = reason == DOM::StyleInvalidationReason::NodeInsertBefore
|
|
|| reason == DOM::StyleInvalidationReason::NodeRemove;
|
|
|
|
// OPTIMIZATION: For :first-child / :last-child / :only-child, the match result only flips for
|
|
// at most one element per insertion/removal, so we can target it precisely instead
|
|
// of invalidating every previous/next sibling that ever observed those pseudo-classes.
|
|
// NB: :first-child / :last-child match on element siblings (skipping text/comment nodes), so we
|
|
// find the adjacent *element* sibling here rather than the adjacent node.
|
|
GC::Ptr<DOM::Element> last_child_transition_target;
|
|
GC::Ptr<DOM::Element> first_child_transition_target;
|
|
if (is_insertion_or_removal) {
|
|
// For NodeInsertBefore this runs after the insertion; for NodeRemove it runs before the
|
|
// removal. In both cases the node is currently in the tree, so the element siblings reflect
|
|
// the state in which "this node is at the trailing/leading element position" → the adjacent
|
|
// element is the one whose :last-child / :first-child match transitions.
|
|
GC::Ptr<DOM::Element> previous_element;
|
|
for (auto* sibling = node.previous_sibling(); sibling; sibling = sibling->previous_sibling()) {
|
|
if (auto* element = as_if<DOM::Element>(sibling)) {
|
|
previous_element = element;
|
|
break;
|
|
}
|
|
}
|
|
GC::Ptr<DOM::Element> next_element;
|
|
for (auto* sibling = node.next_sibling(); sibling; sibling = sibling->next_sibling()) {
|
|
if (auto* element = as_if<DOM::Element>(sibling)) {
|
|
next_element = element;
|
|
break;
|
|
}
|
|
}
|
|
if (!next_element && previous_element)
|
|
last_child_transition_target = previous_element;
|
|
if (!previous_element && next_element)
|
|
first_child_transition_target = next_element;
|
|
}
|
|
|
|
if (is_insertion_or_removal) {
|
|
// OPTIMIZATION: :last-child / :only-child can only flip for the element transitioning into or out of the
|
|
// trailing position, so handle that directly. Only walk all previous siblings if the parent has
|
|
// children affected by selectors whose from-end index can change, such as :nth-last-child.
|
|
if (auto* parent_node = as_if<DOM::ParentNode>(node.parent()); parent_node && parent_node->has_child_affected_by_last_child_pseudo_class()) {
|
|
if (last_child_transition_target && last_child_transition_target->affected_by_last_child_pseudo_class())
|
|
mark_sibling_for_style_update(*last_child_transition_target);
|
|
}
|
|
if (auto* parent_node = as_if<DOM::ParentNode>(node.parent()); parent_node && parent_node->has_child_affected_by_backward_positional_pseudo_class()) {
|
|
auto& counters = node.document().style_invalidation_counters();
|
|
for (auto* sibling = node.previous_sibling(); sibling; sibling = sibling->previous_sibling()) {
|
|
++counters.previous_sibling_invalidation_walk_visits;
|
|
auto* element = as_if<DOM::Element>(sibling);
|
|
if (!element)
|
|
continue;
|
|
if (element->affected_by_backward_positional_pseudo_class())
|
|
mark_sibling_for_style_update(*element);
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t current_sibling_distance = 1;
|
|
for (auto* sibling = node.next_sibling(); sibling; sibling = sibling->next_sibling()) {
|
|
auto* element = as_if<DOM::Element>(sibling);
|
|
if (!element)
|
|
continue;
|
|
|
|
bool needs_to_invalidate = false;
|
|
if (is_insertion_or_removal) {
|
|
if (element->affected_by_indirect_sibling_combinator()) {
|
|
needs_to_invalidate = true;
|
|
} else if (element->affected_by_forward_positional_pseudo_class()) {
|
|
// :nth-child / :nth-of-type / :first-of-type / :only-of-type need every next sibling
|
|
// re-evaluated since their leading indices shift.
|
|
needs_to_invalidate = true;
|
|
} else if (element->affected_by_first_child_pseudo_class() && element == first_child_transition_target) {
|
|
// :first-child / :only-child only flip for the element transitioning into/out of the
|
|
// leading position.
|
|
needs_to_invalidate = true;
|
|
} else if (element->affected_by_direct_sibling_combinator() && current_sibling_distance <= element->sibling_invalidation_distance()) {
|
|
needs_to_invalidate = true;
|
|
}
|
|
} else if (element->affected_by_indirect_sibling_combinator()) {
|
|
needs_to_invalidate = true;
|
|
} else if (element->affected_by_forward_positional_pseudo_class()) {
|
|
needs_to_invalidate = true;
|
|
} else if (element->affected_by_direct_sibling_combinator() && current_sibling_distance <= element->sibling_invalidation_distance()) {
|
|
needs_to_invalidate = true;
|
|
}
|
|
|
|
if (needs_to_invalidate)
|
|
mark_sibling_for_style_update(*element);
|
|
current_sibling_distance++;
|
|
}
|
|
}
|
|
|
|
void mark_ancestors_as_having_child_needing_style_update(DOM::Node& node)
|
|
{
|
|
for (auto* ancestor = node.parent_or_shadow_host(); ancestor; ancestor = ancestor->parent_or_shadow_host())
|
|
ancestor->set_child_needs_style_update(true);
|
|
}
|
|
|
|
void invalidate_style_after_same_parent_move(DOM::Node& node, DOM::StyleInvalidationReason reason)
|
|
{
|
|
if (node.document().needs_full_style_update())
|
|
return;
|
|
|
|
schedule_has_invalidation_for_same_parent_move(node);
|
|
|
|
for (auto* ancestor = node.parent_or_shadow_host(); ancestor; ancestor = ancestor->parent_or_shadow_host()) {
|
|
if (ancestor->entire_subtree_needs_style_update())
|
|
return;
|
|
}
|
|
|
|
if (auto* element = as_if<DOM::Element>(node)) {
|
|
if (element->affected_by_structural_pseudo_class_in_non_subject_position() || element->affected_by_sibling_combinator_in_non_subject_position()) {
|
|
node.set_entire_subtree_needs_style_update(true);
|
|
} else if (element_is_affected_by_same_parent_move(*element)) {
|
|
node.set_needs_style_update(true);
|
|
}
|
|
} else if (!node.is_character_data()) {
|
|
node.set_needs_style_update(true);
|
|
}
|
|
invalidate_structurally_affected_siblings(node, reason);
|
|
mark_ancestors_as_having_child_needing_style_update(node);
|
|
}
|
|
|
|
}
|