Track reasons for |Node::SetNeedsStyleRecalc|

Source/core/dom/ContainerNode.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 984 matching lines @@
 // independent of the focused element changing.
 void ContainerNode::focusStateChanged()
 {
     // If we're just changing the window's active state and the focused node has no
     // renderer we can just ignore the state change.
     if (!renderer())
         return;
 
     if (styleChangeType() < SubtreeStyleChange) {
         if (renderStyle()->affectedByFocus() && renderStyle()->hasPseudoStyle(FIRST_LETTER))
-            setNeedsStyleRecalc(SubtreeStyleChange);
+            setNeedsStyleRecalc(StyleChangeReasonForTracing::FocusPseudoClass, SubtreeStyleChange);
         else if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus())
             document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoFocus, *toElement(this));
         else if (renderStyle()->affectedByFocus())
-            setNeedsStyleRecalc(LocalStyleChange);
+            setNeedsStyleRecalc(StyleChangeReasonForTracing::FocusPseudoClass, LocalStyleChange);

[esprehn, 2014/09/19 04:53:09]

ex. Here changing :focus can either by StyleInvalidator or FocusPseudoClass.

     }
 
     if (renderer() && renderer()->style()->hasAppearance())
         RenderTheme::theme().stateChanged(renderer(), FocusControlState);
 }
 
 void ContainerNode::setFocus(bool received)
 {
     if (focused() == received)
         return;
 
     Node::setFocus(received);
 
     focusStateChanged();
 
     if (renderer() || received)
         return;
 
     // If :focus sets display: none, we lose focus but still need to recalc our style.
     if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus() && styleChangeType() < SubtreeStyleChange)
         document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoFocus, *toElement(this));
     else
-        setNeedsStyleRecalc(LocalStyleChange);
+        setNeedsStyleRecalc(StyleChangeReasonForTracing::FocusPseudoClass, LocalStyleChange);
 }
 
 void ContainerNode::setActive(bool down)
 {
     if (down == active())
         return;
 
     Node::setActive(down);
 
     // FIXME: Why does this not need to handle the display: none transition like :hover does?
     if (renderer()) {
         if (styleChangeType() < SubtreeStyleChange) {
             if (renderStyle()->affectedByActive() && renderStyle()->hasPseudoStyle(FIRST_LETTER))
-                setNeedsStyleRecalc(SubtreeStyleChange);
+                setNeedsStyleRecalc(StyleChangeReasonForTracing::ActivePseudoClass, SubtreeStyleChange);
             else if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByActive())
                 document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoActive, *toElement(this));
             else if (renderStyle()->affectedByActive())
-                setNeedsStyleRecalc(LocalStyleChange);
+                setNeedsStyleRecalc(StyleChangeReasonForTracing::ActivePseudoClass, LocalStyleChange);
         }
 
         if (renderStyle()->hasAppearance())
             RenderTheme::theme().stateChanged(renderer(), PressedControlState);
     }
 }
 
 void ContainerNode::setHovered(bool over)
 {
     if (over == hovered())
         return;
 
     Node::setHovered(over);
 
     // If :hover sets display: none we lose our hover but still need to recalc our style.
     if (!renderer()) {
         if (over)
             return;
         if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByHover() && styleChangeType() < SubtreeStyleChange)
             document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoHover, *toElement(this));
         else
-            setNeedsStyleRecalc(LocalStyleChange);
+            setNeedsStyleRecalc(StyleChangeReasonForTracing::HoverPseudoClass, LocalStyleChange);
         return;
     }
 
     if (styleChangeType() < SubtreeStyleChange) {
         if (renderStyle()->affectedByHover() && renderStyle()->hasPseudoStyle(FIRST_LETTER))
-            setNeedsStyleRecalc(SubtreeStyleChange);
+            setNeedsStyleRecalc(StyleChangeReasonForTracing::HoverPseudoClass, SubtreeStyleChange);
         else if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByHover())
             document().ensureStyleResolver().ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoHover, *toElement(this));
         else if (renderStyle()->affectedByHover())
-            setNeedsStyleRecalc(LocalStyleChange);
+            setNeedsStyleRecalc(StyleChangeReasonForTracing::HoverPseudoClass, LocalStyleChange);
     }
 
     if (renderer()->style()->hasAppearance())
         RenderTheme::theme().stateChanged(renderer(), HoverControlState);
 }
 
 PassRefPtrWillBeRawPtr<HTMLCollection> ContainerNode::children()
 {
     return ensureCachedCollection<HTMLCollection>(NodeChildren);
 }
@@ skipping 152 matching lines @@
         return;
 
     unsigned forceCheckOfNextElementCount = 0;
     bool forceCheckOfAnyElementSibling = false;
     Document& document = this->document();
 
     for (Element* child = ElementTraversal::firstChild(*this); child; child = ElementTraversal::nextSibling(*child)) {
         bool childRulesChanged = child->needsStyleRecalc() && child->styleChangeType() >= SubtreeStyleChange;
 
         if (forceCheckOfNextElementCount || forceCheckOfAnyElementSibling)
-            child->setNeedsStyleRecalc(SubtreeStyleChange);
+            child->setNeedsStyleRecalc(StyleChangeReasonForTracing::SiblingSelector, SubtreeStyleChange);
 
         if (childRulesChanged && hasDirectAdjacentRules)
             forceCheckOfNextElementCount = document.styleEngine()->maxDirectAdjacentSelectors();
         else if (forceCheckOfNextElementCount)
             --forceCheckOfNextElementCount;
 
         forceCheckOfAnyElementSibling = forceCheckOfAnyElementSibling || (childRulesChanged && hasIndirectAdjacentRules);
     }
 }
 
 void ContainerNode::checkForSiblingStyleChanges(SiblingCheckType changeType, Node* nodeBeforeChange, Node* nodeAfterChange)
 {
     if (!inActiveDocument() || document().hasPendingForcedStyleRecalc() || styleChangeType() >= SubtreeStyleChange)
         return;
 
     if (needsStyleRecalc() && childrenAffectedByPositionalRules())
         return;
 
     // Forward positional selectors include nth-child, nth-of-type, first-of-type and only-of-type.
     // The indirect adjacent selector is the ~ selector.
     // Backward positional selectors include nth-last-child, nth-last-of-type, last-of-type and only-of-type.
     // We have to invalidate everything following the insertion point in the forward and indirect adjacent case,
     // and everything before the insertion point in the backward case.
     // |afterChange| is 0 in the parser callback case, so we won't do any work for the forward case if we don't have to.
     // For performance reasons we just mark the parent node as changed, since we don't want to make childrenChanged O(n^2) by crawling all our kids
     // 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(StyleChangeReasonForTracing::SiblingSelector, SubtreeStyleChange);
         return;
     }
 
     // :first-child. In the parser callback case, we don't have to check anything, since we were right the first time.
     // In the DOM case, we only need to do something if |afterChange| is not 0.
     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
     if (childrenAffectedByFirstChildRules() && nodeAfterChange) {
         ASSERT(changeType != FinishedParsingChildren);
         // Find our new first child element.
         Element* firstChildElement = ElementTraversal::firstChild(*this);
         RenderStyle* firstChildElementStyle = firstChildElement ? firstChildElement->renderStyle() : 0;
 
         // Find the first element after the change.
         Element* elementAfterChange = nodeAfterChange->isElementNode() ? toElement(nodeAfterChange) : ElementTraversal::nextSibling(*nodeAfterChange);
         RenderStyle* elementAfterChangeStyle = elementAfterChange ? elementAfterChange->renderStyle() : 0;
 
         // This is the element insertion as first child element case.
         if (firstChildElement != elementAfterChange && elementAfterChangeStyle && elementAfterChangeStyle->firstChildState()) {
             ASSERT(changeType == SiblingElementInserted);
-            elementAfterChange->setNeedsStyleRecalc(SubtreeStyleChange);
+            elementAfterChange->setNeedsStyleRecalc(StyleChangeReasonForTracing::SiblingSelector, SubtreeStyleChange);
         }
 
         // This is the first child element removal case.
         if (changeType == SiblingElementRemoved && firstChildElement == elementAfterChange && firstChildElement && (!firstChildElementStyle || !firstChildElementStyle->firstChildState()))
-            firstChildElement->setNeedsStyleRecalc(SubtreeStyleChange);
+            firstChildElement->setNeedsStyleRecalc(StyleChangeReasonForTracing::SiblingSelector, SubtreeStyleChange);
     }
 
     // :last-child. In the parser callback case, we don't have to check anything, since we were right the first time.
     // In the DOM case, we only need to do something if |afterChange| is not 0.
     if (childrenAffectedByLastChildRules() && nodeBeforeChange) {
         // Find our new last child element.
         Element* lastChildElement = ElementTraversal::lastChild(*this);
         RenderStyle* lastChildElementStyle = lastChildElement ? lastChildElement->renderStyle() : 0;
 
         // Find the last element before the change.
         Element* elementBeforeChange = nodeBeforeChange->isElementNode() ? toElement(nodeBeforeChange) : ElementTraversal::previousSibling(*nodeBeforeChange);
         RenderStyle* elementBeforeChangeStyle = elementBeforeChange ? elementBeforeChange->renderStyle() : 0;
 
         // This is the element insertion as last child element case.
         if (lastChildElement != elementBeforeChange && elementBeforeChangeStyle && elementBeforeChangeStyle->lastChildState()) {
             ASSERT(SiblingElementInserted);
-            elementBeforeChange->setNeedsStyleRecalc(SubtreeStyleChange);
+            elementBeforeChange->setNeedsStyleRecalc(StyleChangeReasonForTracing::SiblingSelector, 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(StyleChangeReasonForTracing::SiblingSelector, 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(StyleChangeReasonForTracing::SiblingSelector, SubtreeStyleChange);
     }
 }
 
 void ContainerNode::invalidateNodeListCachesInAncestors(const QualifiedName* attrName, Element* attributeOwnerElement)
 {
     if (hasRareData() && (!attrName || isAttributeNode())) {
         if (NodeListsNodeData* lists = rareData()->nodeLists()) {
             if (ChildNodeList* childNodeList = lists->childNodeList(*this))
                 childNodeList->invalidateCache();
         }
@@ skipping 91 matching lines @@
         return true;
 
     if (node->isElementNode() && toElement(node)->shadow())
         return true;
 
     return false;
 }
 #endif
 
 } // namespace blink