Factor the style invalidation tree walk out of RuleFeatureSet, and make it generic.

Source/core/css/RuleFeature.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 16 matching lines @@
  */
 
 #include "config.h"
 #include "core/css/RuleFeature.h"
 
 #include "HTMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSSelectorList.h"
 #include "core/css/RuleSet.h"
+#include "core/css/invalidation/StyleInvalidator.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/Node.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/rendering/RenderObject.h"
 #include "wtf/BitVector.h"
 
@@ skipping 314 matching lines @@
 }
 
 RuleFeatureSet::InvalidationList& RuleFeatureSet::ensurePendingInvalidationList(Element* element)
 {
     PendingInvalidationMap::AddResult addResult = m_pendingInvalidationMap.add(element, nullptr);
     if (addResult.isNewEntry)
         addResult.storedValue->value = adoptPtr(new InvalidationList);
     return *addResult.storedValue->value;
 }
 
-void RuleFeatureSet::computeStyleInvalidation(Document& document)
-{
-    Vector<AtomicString> invalidationClasses;
-    if (Element* documentElement = document.documentElement()) {
-        if (documentElement->childNeedsStyleInvalidation())
-            invalidateStyleForClassChange(documentElement, invalidationClasses, false);
-    }
-    document.clearChildNeedsStyleInvalidation();
-    document.clearNeedsStyleInvalidation();
-    m_pendingInvalidationMap.clear();
-}
-
 void RuleFeatureSet::clearStyleInvalidation(Node* node)
 {
     node->clearChildNeedsStyleInvalidation();
     node->clearNeedsStyleInvalidation();
     if (node->isElementNode())
         m_pendingInvalidationMap.remove(toElement(node));
 }
 
-bool RuleFeatureSet::invalidateStyleForClassChangeOnChildren(Element* element, Vector<AtomicString>& invalidationClasses, bool foundInvalidationSet)
+RuleFeatureSet::PendingInvalidationMap& RuleFeatureSet::pendingInvalidationMap()
 {
-    bool someChildrenNeedStyleRecalc = false;
-    for (ShadowRoot* root = element->youngestShadowRoot(); root; root = root->olderShadowRoot()) {
-        for (Element* child = ElementTraversal::firstWithin(*root); child; child = ElementTraversal::nextSibling(*child)) {
-            bool childRecalced = invalidateStyleForClassChange(child, invalidationClasses, foundInvalidationSet);
-            someChildrenNeedStyleRecalc = someChildrenNeedStyleRecalc || childRecalced;
-        }
-        root->clearChildNeedsStyleInvalidation();
-        root->clearNeedsStyleInvalidation();
-    }
-    for (Element* child = ElementTraversal::firstWithin(*element); child; child = ElementTraversal::nextSibling(*child)) {
-        bool childRecalced = invalidateStyleForClassChange(child, invalidationClasses, foundInvalidationSet);
-        someChildrenNeedStyleRecalc = someChildrenNeedStyleRecalc || childRecalced;
-    }
-    return someChildrenNeedStyleRecalc;
-}
-
-bool RuleFeatureSet::invalidateStyleForClassChange(Element* element, Vector<AtomicString>& invalidationClasses, bool foundInvalidationSet)
-{
-    bool thisElementNeedsStyleRecalc = false;
-    int oldSize = invalidationClasses.size();
-    if (element->needsStyleInvalidation()) {
-        if (InvalidationList* invalidationList = m_pendingInvalidationMap.get(element)) {
-            // FIXME: it's really only necessary to clone the render style for this element, not full style recalc.
-            thisElementNeedsStyleRecalc = true;
-            foundInvalidationSet = true;
-            for (InvalidationList::const_iterator it = invalidationList->begin(); it != invalidationList->end(); ++it) {
-                if ((*it)->wholeSubtreeInvalid()) {
-                    element->setNeedsStyleRecalc(SubtreeStyleChange);
-                    // Even though we have set needsStyleRecalc on the whole subtree, we need to keep walking over the subtree
-                    // in order to clear the invalidation dirty bits on all elements.
-                    // FIXME: we can optimize this by having a dedicated function that just traverses the tree and removes the dirty bits,
-                    // without checking classes etc.
-                    break;
-                }
-                (*it)->getClasses(invalidationClasses);
-            }
-        }
-    }
-
-    if (element->hasClass()) {
-        const SpaceSplitString& classNames = element->classNames();
-        for (Vector<AtomicString>::const_iterator it = invalidationClasses.begin(); it != invalidationClasses.end(); ++it) {
-            if (classNames.contains(*it)) {
-                thisElementNeedsStyleRecalc = true;
-                break;
-            }
-        }
-    }
-
-    bool someChildrenNeedStyleRecalc = false;
-    // foundInvalidationSet will be true if we are in a subtree of a node with a DescendantInvalidationSet on it.
-    // We need to check all nodes in the subtree of such a node.
-    if (foundInvalidationSet || element->childNeedsStyleInvalidation()) {
-        someChildrenNeedStyleRecalc = invalidateStyleForClassChangeOnChildren(element, invalidationClasses, foundInvalidationSet);
-    }
-
-    if (thisElementNeedsStyleRecalc) {
-        element->setNeedsStyleRecalc(LocalStyleChange);
-    } else if (foundInvalidationSet && someChildrenNeedStyleRecalc) {
-        // Clone the RenderStyle in order to preserve correct style sharing, if possible. Otherwise recalc style.
-        if (RenderObject* renderer = element->renderer()) {
-            ASSERT(renderer->style());
-            renderer->setStyleInternal(RenderStyle::clone(renderer->style()));
-        } else {
-            element->setNeedsStyleRecalc(LocalStyleChange);
-        }
-    }
-
-    invalidationClasses.remove(oldSize, invalidationClasses.size() - oldSize);
-    element->clearChildNeedsStyleInvalidation();
-    element->clearNeedsStyleInvalidation();
-
-    return thisElementNeedsStyleRecalc;
+    return m_pendingInvalidationMap;
 }
 
 } // namespace WebCore