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 70 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::rescheduleSiblingInvalidationSetsForRemovedElement(Element& elementFrom, Element& elementTo, bool invalidateElementTo)
+{
+    PendingInvalidations* pendingInvalidationsFrom = m_pendingInvalidationMap.get(&elementFrom);
+    if (!pendingInvalidationsFrom || pendingInvalidationsFrom->siblings().isEmpty())
+        return;
+
+    scheduleDescendantsFromSiblingSets(elementTo, pendingInvalidationsFrom->siblings());
+    ensurePendingInvalidations(elementTo).siblings().appendVector(pendingInvalidationsFrom->siblings());
+    elementTo.setNeedsStyleInvalidation();
+}
+
+void StyleInvalidator::scheduleDescendantsFromSiblingSets(Element& element, const InvalidationSetVector& siblingSets)
+{
+    bool needsStyleInvalidation = false;
+    PendingInvalidations& pendingInvalidations = ensurePendingInvalidations(element);
+    for (const auto& invalidationSet : siblingSets) {
+        if (!invalidationSet->invalidatesElement(element))
+            continue;
+
+        if (invalidationSet->invalidatesSelf())
+            element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
+
+        DescendantInvalidationSet* descendants = toSiblingInvalidationSet(*invalidationSet).siblingDescendants();
+        if (!descendants)
+            continue;
+
+        if (descendants->wholeSubtreeInvalid()) {
+            element.setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
+            continue;
+        }
+        if (descendants->isEmpty())
+            continue;
+
+        pendingInvalidations.descendants().append(descendants);
+        needsStyleInvalidation = true;
+    }
+    if (needsStyleInvalidation)
+        element.setNeedsStyleInvalidation();
+}
+
 void StyleInvalidator::clearInvalidation(Element& element)
 {
     if (!element.needsStyleInvalidation())
         return;
     m_pendingInvalidationMap.remove(&element);
     element.clearNeedsStyleInvalidation();
 }
 
 PendingInvalidations& StyleInvalidator::ensurePendingInvalidations(Element& element)
 {
@@ skipping 226 matching lines @@
             distributedNode->setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
     }
 }
 
 DEFINE_TRACE(StyleInvalidator)
 {
     visitor->trace(m_pendingInvalidationMap);
 }
 
 } // namespace blink