Inline style should always be cacheable in matched declarations cache

https://bugs.webkit.org/show_bug.cgi?id=260254
rdar://113960228

Reviewed by Alan Baradlay.

Mutable inline style (created by modification via JS wrapper) prevents style caching
in the matched declarations cache. This patch turns any mutable style immutable during
style resolution so we can cache it. Due to deduplication the cache entries can be reused
accross elements and mutations.

* Source/WebCore/dom/ElementData.cpp:
(WebCore::UniqueElementData::UniqueElementData):
* Source/WebCore/dom/ElementData.h:

Save the immutable style in UniqueElementData.

* Source/WebCore/dom/StyledElement.cpp:
(WebCore::StyledElement::styleAttributeChanged):
(WebCore::StyledElement::invalidateStyleAttribute):

Take care to invalidate the cached immutable copy.

(WebCore::StyledElement::inlineStyleForStyleResolution const):

The accessor constructs ImmutableStyleProperties lazily on demand.

* Source/WebCore/dom/StyledElement.h:
* Source/WebCore/style/ElementRuleCollector.cpp:
(WebCore::Style::ElementRuleCollector::addElementInlineStyleProperties):

Allow caching.

Canonical link: https://commits.webkit.org/267035@main

Source/WebCore/dom/ElementData.cpp

@@ -136,6 +136,7 @@ UniqueElementData::UniqueElementData()
 UniqueElementData::UniqueElementData(const UniqueElementData& other)
     : ElementData(other, true)
     , m_presentationalHintStyle(other.m_presentationalHintStyle)
+    , m_inlineStyleForStyleResolution(other.m_inlineStyleForStyleResolution)
     , m_attributeVector(other.m_attributeVector)
 {
     if (other.m_inlineStyle)
@@ -149,6 +150,7 @@ UniqueElementData::UniqueElementData(const ShareableElementData& other)
     // An ShareableElementData should never have a mutable inline StyleProperties attached.
     ASSERT(!other.m_inlineStyle || !other.m_inlineStyle->isMutable());
     m_inlineStyle = other.m_inlineStyle;
+    m_inlineStyleForStyleResolution = downcast<ImmutableStyleProperties>(other.m_inlineStyle);
 }
 
 Ref<UniqueElementData> ElementData::makeUniqueCopy() const

Source/WebCore/dom/ElementData.h

@@ -222,6 +222,7 @@ class UniqueElementData : public ElementData {
     static ptrdiff_t attributeVectorMemoryOffset() { return OBJECT_OFFSETOF(UniqueElementData, m_attributeVector); }
 
     mutable RefPtr<ImmutableStyleProperties> m_presentationalHintStyle;
+    mutable RefPtr<ImmutableStyleProperties> m_inlineStyleForStyleResolution;
     typedef Vector<Attribute, 4> AttributeVector;
     AttributeVector m_attributeVector;
 };

Source/WebCore/dom/StyledElement.cpp

@@ -155,6 +155,9 @@ void StyledElement::styleAttributeChanged(const AtomString& newStyleString, Attr
 
     elementData()->setStyleAttributeIsDirty(false);
 
+    if (auto* uniqueElementData = dynamicDowncast<UniqueElementData>(*elementData()))
+        uniqueElementData->m_inlineStyleForStyleResolution = nullptr;
+
     invalidateStyleInternal();
     InspectorInstrumentation::didInvalidateStyleAttr(*this);
 }
@@ -167,6 +170,10 @@ void StyledElement::invalidateStyleAttribute()
     }
 
     elementData()->setStyleAttributeIsDirty(true);
+
+    if (auto* uniqueElementData = dynamicDowncast<UniqueElementData>(*elementData()))
+        uniqueElementData->m_inlineStyleForStyleResolution = nullptr;
+
     invalidateStyleInternal();
 
     // In the rare case of selectors like "[style] ~ div" we need to synchronize immediately to invalidate.
@@ -319,4 +326,23 @@ void StyledElement::addPropertyToPresentationalHintStyle(MutableStyleProperties&
     style.setProperty(propertyID, value, false, CSSParserContext(document()));
 }
 
+const ImmutableStyleProperties* StyledElement::inlineStyleForStyleResolution() const
+{
+    if (!elementData())
+        return nullptr;
+
+    auto* inlineStyle = elementData()->m_inlineStyle.get();
+    if (!inlineStyle)
+        return nullptr;
+
+    if (auto* immutableStyle = dynamicDowncast<ImmutableStyleProperties>(*inlineStyle))
+        return immutableStyle;
+
+    auto& uniqueElementData = downcast<UniqueElementData>(*elementData());
+    if (!uniqueElementData.m_inlineStyleForStyleResolution)
+        uniqueElementData.m_inlineStyleForStyleResolution = inlineStyle->immutableCopyIfNeeded();
+
+    return uniqueElementData.m_inlineStyleForStyleResolution.get();
+}
+
 }

Source/WebCore/dom/StyledElement.h

@@ -47,7 +47,9 @@ class StyledElement : public Element {
     void invalidateStyleAttribute();
 
     const StyleProperties* inlineStyle() const { return elementData() ? elementData()->m_inlineStyle.get() : nullptr; }
-
+    // Use immutable style for style resolution for efficient caching.
+    const ImmutableStyleProperties* inlineStyleForStyleResolution() const;
+
     bool setInlineStyleProperty(CSSPropertyID, CSSValueID identifier, bool important = false);
     bool setInlineStyleProperty(CSSPropertyID, CSSPropertyID identifier, bool important = false);
     WEBCORE_EXPORT bool setInlineStyleProperty(CSSPropertyID, double value, CSSUnitType, bool important = false);

Source/WebCore/style/ElementRuleCollector.cpp

@@ -636,10 +636,8 @@ void ElementRuleCollector::addElementInlineStyleProperties(bool includeSMILPrope
     if (!is<StyledElement>(element()))
         return;
 
-    if (auto* inlineStyle = downcast<StyledElement>(element()).inlineStyle()) {
-        bool isInlineStyleCacheable = !inlineStyle->isMutable();
-        addElementStyleProperties(inlineStyle, RuleSet::cascadeLayerPriorityForUnlayered, isInlineStyleCacheable, FromStyleAttribute::Yes);
-    }
+    if (auto* inlineStyle = downcast<StyledElement>(element()).inlineStyleForStyleResolution())
+        addElementStyleProperties(inlineStyle, RuleSet::cascadeLayerPriorityForUnlayered, true, FromStyleAttribute::Yes);
 
     if (includeSMILProperties && is<SVGElement>(element()))
         addElementStyleProperties(downcast<SVGElement>(element()).animatedSMILStyleProperties(), RuleSet::cascadeLayerPriorityForUnlayered, false /* isCacheable */);