Track reasons for |Node::SetNeedsStyleRecalc|

Source/core/dom/ContainerNode.cpp

Index: Source/core/dom/ContainerNode.cpp
diff --git a/Source/core/dom/ContainerNode.cpp b/Source/core/dom/ContainerNode.cpp
index 114e63d4ece6650a7c8627650a51f1a87a5104b0..f0d4ab2db8ef80379abaa7f626e402c44c4f504e 100644
--- a/Source/core/dom/ContainerNode.cpp
+++ b/Source/core/dom/ContainerNode.cpp
@@ -1002,11 +1002,11 @@ void ContainerNode::focusStateChanged()
 
     if (styleChangeType() < SubtreeStyleChange) {
         if (renderStyle()->affectedByFocus() && renderStyle()->hasPseudoStyle(FIRST_LETTER))
-            setNeedsStyleRecalc(SubtreeStyleChange);
+            setNeedsStyleRecalc(StyleRecalcDueToFocusPseudoClass, SubtreeStyleChange);
         else if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus())
             document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoFocus, *toElement(this));
         else if (renderStyle()->affectedByFocus())
-            setNeedsStyleRecalc(LocalStyleChange);
+            setNeedsStyleRecalc(StyleRecalcDueToFocusPseudoClass, LocalStyleChange);
     }
 
     if (renderer() && renderer()->style()->hasAppearance())
@@ -1029,7 +1029,7 @@ void ContainerNode::setFocus(bool received)
     if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus() && styleChangeType() < SubtreeStyleChange)
         document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoFocus, *toElement(this));
     else
-        setNeedsStyleRecalc(LocalStyleChange);
+        setNeedsStyleRecalc(StyleRecalcDueToFocusPseudoClass, LocalStyleChange);
 }
 
 void ContainerNode::setActive(bool down)
@@ -1043,11 +1043,11 @@ void ContainerNode::setActive(bool down)
     if (renderer()) {
         if (styleChangeType() < SubtreeStyleChange) {
             if (renderStyle()->affectedByActive() && renderStyle()->hasPseudoStyle(FIRST_LETTER))
-                setNeedsStyleRecalc(SubtreeStyleChange);
+                setNeedsStyleRecalc(StyleRecalcDueToActivePseudoClass, SubtreeStyleChange);

[pdr., 2014/09/06 22:36:27]

We may want to call this StyleRecalcDueToActiveAndFirstLetterPseudoClasses
(here, and for focus and hover).

[kouhei (in TOK), 2014/09/08 23:29:12]

I think the existing names are correct here. We get here only on :active pseudo
class change. IIUC, the if condition is checking if the RenderStyle also has a
:first-letter as we can't use a delayed style invalidation in that case.

             else if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByActive())
                 document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoActive, *toElement(this));
             else if (renderStyle()->affectedByActive())
-                setNeedsStyleRecalc(LocalStyleChange);
+                setNeedsStyleRecalc(StyleRecalcDueToActivePseudoClass, LocalStyleChange);
         }
 
         if (renderStyle()->hasAppearance())
@@ -1069,17 +1069,17 @@ void ContainerNode::setHovered(bool over)
         if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByHover() && styleChangeType() < SubtreeStyleChange)
             document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoHover, *toElement(this));
         else
-            setNeedsStyleRecalc(LocalStyleChange);
+            setNeedsStyleRecalc(StyleRecalcDueToHoverPseudoClass, LocalStyleChange);
         return;
     }
 
     if (styleChangeType() < SubtreeStyleChange) {
         if (renderStyle()->affectedByHover() && renderStyle()->hasPseudoStyle(FIRST_LETTER))
-            setNeedsStyleRecalc(SubtreeStyleChange);
+            setNeedsStyleRecalc(StyleRecalcDueToHoverPseudoClass, SubtreeStyleChange);
         else if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByHover())
             document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoHover, *toElement(this));
         else if (renderStyle()->affectedByHover())
-            setNeedsStyleRecalc(LocalStyleChange);
+            setNeedsStyleRecalc(StyleRecalcDueToHoverPseudoClass, LocalStyleChange);
     }
 
     if (renderer()->style()->hasAppearance())
@@ -1221,7 +1221,7 @@ void ContainerNode::checkForChildrenAdjacentRuleChanges()
         bool childRulesChanged = child->needsStyleRecalc() && child->styleChangeType() >= SubtreeStyleChange;
 
         if (forceCheckOfNextElementCount || forceCheckOfAnyElementSibling)
-            child->setNeedsStyleRecalc(SubtreeStyleChange);
+            child->setNeedsStyleRecalc(StyleRecalcDueToSiblingSelector, SubtreeStyleChange);
 
         if (childRulesChanged && hasDirectAdjacentRules)
             forceCheckOfNextElementCount = document.styleEngine()->maxDirectAdjacentSelectors();
@@ -1250,7 +1250,7 @@ void ContainerNode::checkForSiblingStyleChanges(SiblingCheckType changeType, Nod
     // here. recalcStyle will then force a walk of the children when it sees that this has happened.
     if (((childrenAffectedByForwardPositionalRules() || childrenAffectedByIndirectAdjacentRules()) && nodeAfterChange)
         || (childrenAffectedByBackwardPositionalRules() && nodeBeforeChange)) {
-        setNeedsStyleRecalc(SubtreeStyleChange);
+        setNeedsStyleRecalc(StyleRecalcDueToSiblingSelector, SubtreeStyleChange);
         return;
     }
 
@@ -1270,12 +1270,12 @@ void ContainerNode::checkForSiblingStyleChanges(SiblingCheckType changeType, Nod
         // This is the element insertion as first child element case.
         if (firstChildElement != elementAfterChange && elementAfterChangeStyle && elementAfterChangeStyle->firstChildState()) {
             ASSERT(changeType == SiblingElementInserted);
-            elementAfterChange->setNeedsStyleRecalc(SubtreeStyleChange);
+            elementAfterChange->setNeedsStyleRecalc(StyleRecalcDueToSiblingSelector, SubtreeStyleChange);
         }
 
         // This is the first child element removal case.
         if (changeType == SiblingElementRemoved && firstChildElement == elementAfterChange && firstChildElement && (!firstChildElementStyle || !firstChildElementStyle->firstChildState()))
-            firstChildElement->setNeedsStyleRecalc(SubtreeStyleChange);
+            firstChildElement->setNeedsStyleRecalc(StyleRecalcDueToSiblingSelector, SubtreeStyleChange);
     }
 
     // :last-child. In the parser callback case, we don't have to check anything, since we were right the first time.
@@ -1292,20 +1292,20 @@ void ContainerNode::checkForSiblingStyleChanges(SiblingCheckType changeType, Nod
         // This is the element insertion as last child element case.
         if (lastChildElement != elementBeforeChange && elementBeforeChangeStyle && elementBeforeChangeStyle->lastChildState()) {
             ASSERT(SiblingElementInserted);
-            elementBeforeChange->setNeedsStyleRecalc(SubtreeStyleChange);
+            elementBeforeChange->setNeedsStyleRecalc(StyleRecalcDueToSiblingSelector, SubtreeStyleChange);
         }
 
         // This is the last child element removal case. The parser callback case is similar to node removal as well in that we need to change the last child
         // to match now.
         if ((changeType == SiblingElementRemoved || changeType == FinishedParsingChildren) && lastChildElement == elementBeforeChange && lastChildElement && (!lastChildElementStyle || !lastChildElementStyle->lastChildState()))
-            lastChildElement->setNeedsStyleRecalc(SubtreeStyleChange);
+            lastChildElement->setNeedsStyleRecalc(StyleRecalcDueToSiblingSelector, SubtreeStyleChange);
     }
 
     // The + selector. We need to invalidate the first element following the change. It is the only possible element
     // that could be affected by this DOM change.
     if (childrenAffectedByDirectAdjacentRules() && nodeAfterChange) {
         if (Element* elementAfterChange = nodeAfterChange->isElementNode() ? toElement(nodeAfterChange) : ElementTraversal::nextSibling(*nodeAfterChange))
-            elementAfterChange->setNeedsStyleRecalc(SubtreeStyleChange);
+            elementAfterChange->setNeedsStyleRecalc(StyleRecalcDueToSiblingSelector, SubtreeStyleChange);
     }
 }