Schedule sibling invalidation sets for sibling insert/remove.

third_party/WebKit/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 "core/css/invalidation/StyleInvalidator.h"
 
 #include "core/css/invalidation/InvalidationSet.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
@@ skipping 71 matching lines @@
     for (auto& invalidationSet : invalidationLists.descendants) {
         ASSERT(!invalidationSet->wholeSubtreeInvalid());
         if (invalidationSet->isEmpty())
             continue;
         if (pendingInvalidations.descendants().contains(invalidationSet))
             continue;
         pendingInvalidations.descendants().append(invalidationSet);
     }
 }
 
-void StyleInvalidator::clearInvalidation(Element& element)
+void StyleInvalidator::scheduleSiblingInvalidationsAsDescendants(const InvalidationLists& invalidationLists, ContainerNode& schedulingParent)
 {
-    if (!element.needsStyleInvalidation())
+    if (invalidationLists.siblings.isEmpty())
         return;
-    m_pendingInvalidationMap.remove(&element);
-    element.clearNeedsStyleInvalidation();
+
+    PendingInvalidations& pendingInvalidations = ensurePendingInvalidations(schedulingParent);
+
+    for (auto& invalidationSet : invalidationLists.siblings) {
+        if (invalidationSet->invalidatesSelf() && !pendingInvalidations.descendants().contains(invalidationSet))
+            pendingInvalidations.descendants().append(invalidationSet);
+
+        if (DescendantInvalidationSet* descendants = toSiblingInvalidationSet(*invalidationSet).siblingDescendants()) {
+            if (!pendingInvalidations.descendants().contains(descendants))
+                pendingInvalidations.descendants().append(descendants);
+        }
+    }
+    schedulingParent.setNeedsStyleInvalidation();
 }
 
-PendingInvalidations& StyleInvalidator::ensurePendingInvalidations(Element& element)
+void StyleInvalidator::clearInvalidation(ContainerNode& node)
 {
-    PendingInvalidationMap::AddResult addResult = m_pendingInvalidationMap.add(&element, nullptr);
+    if (!node.needsStyleInvalidation())
+        return;
+    m_pendingInvalidationMap.remove(&node);
+    node.clearNeedsStyleInvalidation();
+}
+
+PendingInvalidations& StyleInvalidator::ensurePendingInvalidations(ContainerNode& node)
+{
+    PendingInvalidationMap::AddResult addResult = m_pendingInvalidationMap.add(&node, nullptr);
     if (addResult.isNewEntry)
         addResult.storedValue->value = wrapUnique(new PendingInvalidations());
     return *addResult.storedValue->value;
 }
 
 StyleInvalidator::StyleInvalidator()
 {
     s_tracingEnabled = TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"));
     InvalidationSet::cacheTracingFlag();
 }
 
 StyleInvalidator::~StyleInvalidator()
 {
 }
 
-void StyleInvalidator::RecursionData::pushInvalidationSet(const DescendantInvalidationSet& invalidationSet)
+void StyleInvalidator::RecursionData::pushInvalidationSet(const InvalidationSet& invalidationSet)
 {
     ASSERT(!m_wholeSubtreeInvalid);
     ASSERT(!invalidationSet.wholeSubtreeInvalid());
     ASSERT(!invalidationSet.isEmpty());
     if (invalidationSet.treeBoundaryCrossing())
         m_treeBoundaryCrossing = true;
     if (invalidationSet.insertionPointCrossing())
         m_insertionPointCrossing = true;
     if (invalidationSet.invalidatesSlotted())
         m_invalidatesSlotted = true;
@@ skipping 71 matching lines @@
             }
 
             if (!descendants->isEmpty())
                 recursionData.pushInvalidationSet(*descendants);
         }
 
     }
     return thisElementNeedsStyleRecalc;
 }
 
-void StyleInvalidator::pushInvalidationSetsForElement(Element& element, RecursionData& recursionData, SiblingData& siblingData)
+void StyleInvalidator::pushInvalidationSetsForContainerNode(ContainerNode& node, RecursionData& recursionData, SiblingData& siblingData)
 {
-    PendingInvalidations* pendingInvalidations = m_pendingInvalidationMap.get(&element);
+    PendingInvalidations* pendingInvalidations = m_pendingInvalidationMap.get(&node);
     ASSERT(pendingInvalidations);
 
     for (const auto& invalidationSet : pendingInvalidations->siblings())
         siblingData.pushInvalidationSet(toSiblingInvalidationSet(*invalidationSet));
 
-    if (element.getStyleChangeType() >= SubtreeStyleChange)
+    if (node.getStyleChangeType() >= SubtreeStyleChange)
         return;
 
     if (!pendingInvalidations->descendants().isEmpty()) {
         for (const auto& invalidationSet : pendingInvalidations->descendants())
-            recursionData.pushInvalidationSet(toDescendantInvalidationSet(*invalidationSet));
+            recursionData.pushInvalidationSet(*invalidationSet);
         if (UNLIKELY(*s_tracingEnabled)) {
             TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
                 "StyleInvalidatorInvalidationTracking",
                 TRACE_EVENT_SCOPE_THREAD,
-                "data", InspectorStyleInvalidatorInvalidateEvent::invalidationList(element, pendingInvalidations->descendants()));
+                "data", InspectorStyleInvalidatorInvalidateEvent::invalidationList(node, pendingInvalidations->descendants()));
         }
     }
 }
 
 ALWAYS_INLINE bool StyleInvalidator::checkInvalidationSetsAgainstElement(Element& element, RecursionData& recursionData, SiblingData& siblingData)
 {
     if (recursionData.wholeSubtreeInvalid())
         return false;
 
     bool thisElementNeedsStyleRecalc = false;
     if (element.getStyleChangeType() >= SubtreeStyleChange) {
         recursionData.setWholeSubtreeInvalid();
     } else {
         thisElementNeedsStyleRecalc = recursionData.matchesCurrentInvalidationSets(element);
         if (UNLIKELY(!siblingData.isEmpty()))
             thisElementNeedsStyleRecalc |= siblingData.matchCurrentInvalidationSets(element, recursionData);
     }
 
     if (UNLIKELY(element.needsStyleInvalidation()))
-        pushInvalidationSetsForElement(element, recursionData, siblingData);
+        pushInvalidationSetsForContainerNode(element, recursionData, siblingData);
 
     return thisElementNeedsStyleRecalc;
 }
 
 bool StyleInvalidator::invalidateShadowRootChildren(Element& element, RecursionData& recursionData)
 {
     bool someChildrenNeedStyleRecalc = false;
     for (ShadowRoot* root = element.youngestShadowRoot(); root; root = root->olderShadowRoot()) {
         if (!recursionData.treeBoundaryCrossing() && !root->childNeedsStyleInvalidation() && !root->needsStyleInvalidation())
             continue;
+        RecursionCheckpoint checkpoint(&recursionData);
         SiblingData siblingData;
+        if (UNLIKELY(root->needsStyleInvalidation()))
+            pushInvalidationSetsForContainerNode(*root, recursionData, siblingData);
         for (Element* child = ElementTraversal::firstChild(*root); child; child = ElementTraversal::nextSibling(*child)) {
             bool childRecalced = invalidate(*child, recursionData, siblingData);
             someChildrenNeedStyleRecalc = someChildrenNeedStyleRecalc || childRecalced;
         }
         root->clearChildNeedsStyleInvalidation();
         root->clearNeedsStyleInvalidation();
     }
     return someChildrenNeedStyleRecalc;
 }
 
@@ skipping 58 matching lines @@
             distributedNode->setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
     }
 }
 
 DEFINE_TRACE(StyleInvalidator)
 {
     visitor->trace(m_pendingInvalidationMap);
 }
 
 } // namespace blink