AttributeChangeInvalidation.cpp [plain text]
#include "config.h"
#include "AttributeChangeInvalidation.h"
#include "DocumentRuleSets.h"
#include "ElementIterator.h"
#include "ShadowRoot.h"
#include "StyleInvalidationAnalysis.h"
#include "StyleResolver.h"
#include "StyleScope.h"
namespace WebCore {
namespace Style {
static bool mayBeAffectedByAttributeChange(DocumentRuleSets& ruleSets, bool isHTML, const QualifiedName& attributeName)
{
auto& nameSet = isHTML ? ruleSets.features().attributeCanonicalLocalNamesInRules : ruleSets.features().attributeLocalNamesInRules;
return nameSet.contains(attributeName.localName().impl());
}
static bool mayBeAffectedByHostRules(const Element& element, const QualifiedName& attributeName)
{
auto* shadowRoot = element.shadowRoot();
if (!shadowRoot)
return false;
auto& shadowRuleSets = shadowRoot->styleScope().resolver().ruleSets();
if (shadowRuleSets.authorStyle().hostPseudoClassRules().isEmpty())
return false;
return mayBeAffectedByAttributeChange(shadowRuleSets, element.isHTMLElement(), attributeName);
}
static bool mayBeAffectedBySlottedRules(const Element& element, const QualifiedName& attributeName)
{
for (auto* shadowRoot : assignedShadowRootsIfSlotted(element)) {
auto& ruleSets = shadowRoot->styleScope().resolver().ruleSets();
if (ruleSets.authorStyle().slottedPseudoElementRules().isEmpty())
continue;
if (mayBeAffectedByAttributeChange(ruleSets, element.isHTMLElement(), attributeName))
return true;
}
return false;
}
void AttributeChangeInvalidation::invalidateStyle(const QualifiedName& attributeName, const AtomicString& oldValue, const AtomicString& newValue)
{
if (newValue == oldValue)
return;
auto& ruleSets = m_element.styleResolver().ruleSets();
bool isHTML = m_element.isHTMLElement();
bool mayAffectStyle = mayBeAffectedByAttributeChange(ruleSets, isHTML, attributeName)
|| mayBeAffectedByHostRules(m_element, attributeName)
|| mayBeAffectedBySlottedRules(m_element, attributeName);
if (!mayAffectStyle)
return;
if (!isHTML) {
m_element.invalidateStyleForSubtree();
return;
}
if (m_element.shadowRoot() && ruleSets.authorStyle().hasShadowPseudoElementRules()) {
m_element.invalidateStyleForSubtree();
return;
}
m_element.invalidateStyle();
if (!childrenOfType<Element>(m_element).first())
return;
auto* attributeRules = ruleSets.ancestorAttributeRulesForHTML(attributeName.localName().impl());
if (!attributeRules)
return;
for (auto* selector : attributeRules->attributeSelectors) {
bool oldMatches = oldValue.isNull() ? false : SelectorChecker::attributeSelectorMatches(m_element, attributeName, oldValue, *selector);
bool newMatches = newValue.isNull() ? false : SelectorChecker::attributeSelectorMatches(m_element, attributeName, newValue, *selector);
if (oldMatches != newMatches) {
m_descendantInvalidationRuleSet = attributeRules->ruleSet.get();
return;
}
}
}
void AttributeChangeInvalidation::invalidateDescendants()
{
if (!m_descendantInvalidationRuleSet)
return;
StyleInvalidationAnalysis invalidationAnalysis(*m_descendantInvalidationRuleSet);
invalidationAnalysis.invalidateStyle(m_element);
}
}
}