Refactor StyleInvalidator to encapsulate all style invalidation state.

Source/core/css/invalidation/StyleInvalidator.cpp

 
 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.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/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/rendering/RenderObject.h"
 
 namespace WebCore {
 
-void StyleInvalidator::invalidate()
+void StyleInvalidator::invalidate(Document& document)
 {
-    if (Element* documentElement = m_document.documentElement())
+    if (Element* documentElement = document.documentElement())
         invalidate(*documentElement);
-    m_document.clearChildNeedsStyleInvalidation();
-    m_document.clearNeedsStyleInvalidation();
-    m_pendingInvalidationMap.clear();
+    document.clearChildNeedsStyleInvalidation();
+    document.clearNeedsStyleInvalidation();
+    clear();
 }
 
-StyleInvalidator::StyleInvalidator(Document& document)
-    : m_document(document)
-    , m_pendingInvalidationMap(document.styleResolver()->ruleFeatureSet().pendingInvalidationMap())
+void StyleInvalidator::scheduleInvalidation(PassRefPtr<DescendantInvalidationSet> invalidationSet, Element* element)
+{
+    ensurePendingInvalidationList(element).append(invalidationSet);
+    element->setNeedsStyleInvalidation();
+}
+
+StyleInvalidator::InvalidationList& StyleInvalidator::ensurePendingInvalidationList(Element* element)

[esprehn, 2014/03/31 18:20:39]

by reference

[chrishtr, 2014/03/31 19:22:59]

Done.

+{
+    PendingInvalidationMap::AddResult addResult = m_pendingInvalidationMap.add(element, nullptr);
+    if (addResult.isNewEntry)
+        addResult.storedValue->value = adoptPtr(new InvalidationList);
+    return *addResult.storedValue->value;
+}
+
+void StyleInvalidator::clearStyleInvalidation(Node* node)
+{
+    node->clearChildNeedsStyleInvalidation();
+    node->clearNeedsStyleInvalidation();
+    if (node->isElementNode())
+        m_pendingInvalidationMap.remove(toElement(node));
+}
+
+void StyleInvalidator::clear()
+{
+    m_pendingInvalidationMap.clear();
+    m_recursionData.clear();

[esprehn, 2014/03/31 18:20:39]

How is it possible to have recursion data at this point?

[chrishtr, 2014/03/31 19:22:59]

It should not be possible. Removed.

+}
+
+void StyleInvalidator::RecursionData::clear();
+{
+    m_invalidationClasses.clear();
+    m_invalidationAttributes.clear();
+    m_foundInvalidationSet = false;
+}
+
+StyleInvalidator::RecursionData::RecursionData()
+{
+    clear();
+}
+
+StyleInvalidator::StyleInvalidator()
 { }
 
 void StyleInvalidator::RecursionData::pushInvalidationSet(const DescendantInvalidationSet& invalidationSet)
 {
     invalidationSet.getClasses(m_invalidationClasses);
     invalidationSet.getAttributes(m_invalidationAttributes);
     m_foundInvalidationSet = true;
 }
 
 bool StyleInvalidator::RecursionData::matchesCurrentInvalidationSets(Element& element)
@@ skipping 12 matching lines @@
         }
     }
 
     return false;
 }
 
 bool StyleInvalidator::checkInvalidationSetsAgainstElement(Element& element)
 {
     bool thisElementNeedsStyleRecalc = false;
     if (element.needsStyleInvalidation()) {
-        if (RuleFeatureSet::InvalidationList* invalidationList = m_pendingInvalidationMap.get(&element)) {
+        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;
-            for (RuleFeatureSet::InvalidationList::const_iterator it = invalidationList->begin(); it != invalidationList->end(); ++it) {
+            for (InvalidationList::const_iterator it = invalidationList->begin(); it != invalidationList->end(); ++it) {
                 m_recursionData.pushInvalidationSet(**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;
                 }
             }
@@ skipping 46 matching lines @@
         }
     }
 
     element.clearChildNeedsStyleInvalidation();
     element.clearNeedsStyleInvalidation();
 
     return thisElementNeedsStyleRecalc;
 }
 
 } // namespace WebCore