Avoid style invalidation for empty sets.

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/css/invalidation/DescendantInvalidationSet.h"
@@ skipping 25 matching lines @@
     if (Element* documentElement = document.documentElement())
         invalidate(*documentElement, recursionData);
     document.clearChildNeedsStyleInvalidation();
     document.clearNeedsStyleInvalidation();
     clearPendingInvalidations();
 }
 
 void StyleInvalidator::scheduleInvalidation(PassRefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet, Element& element)
 {
     ASSERT(element.inActiveDocument());
-    ASSERT(element.styleChangeType() < SubtreeStyleChange);
+    if (element.styleChangeType() >= SubtreeStyleChange)
+        return;
+    if (invalidationSet->wholeSubtreeInvalid()) {
+        element.setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
+        clearInvalidation(element);
+        return;
+    }
+    if (invalidationSet->isEmpty()) {
+        element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
+        return;
+    }
+
     InvalidationList& list = ensurePendingInvalidationList(element);
-    // If we're already going to invalidate the whole subtree we don't need to store any new sets.
-    if (!list.isEmpty() && list.last()->wholeSubtreeInvalid())
-        return;
-    // If this set would invalidate the whole subtree we can discard all existing sets.
-    if (invalidationSet->wholeSubtreeInvalid())
-        list.clear();
     list.append(invalidationSet);
     element.setNeedsStyleInvalidation();
 }
 
 StyleInvalidator::InvalidationList& StyleInvalidator::ensurePendingInvalidationList(Element& element)
 {
     PendingInvalidationMap::AddResult addResult = m_pendingInvalidationMap.add(&element, nullptr);
     if (addResult.isNewEntry)
         addResult.storedValue->value = adoptPtrWillBeNoop(new InvalidationList);
     return *addResult.storedValue->value;
@@ skipping 16 matching lines @@
     DescendantInvalidationSet::cacheTracingFlag();
 }
 
 StyleInvalidator::~StyleInvalidator()
 {
 }
 
 void StyleInvalidator::RecursionData::pushInvalidationSet(const DescendantInvalidationSet& invalidationSet)
 {
     ASSERT(!m_wholeSubtreeInvalid);
+    ASSERT(!invalidationSet.wholeSubtreeInvalid());
+    ASSERT(!invalidationSet.isEmpty());
     if (invalidationSet.treeBoundaryCrossing())
         m_treeBoundaryCrossing = true;
     if (invalidationSet.insertionPointCrossing())
         m_insertionPointCrossing = true;
-    if (invalidationSet.wholeSubtreeInvalid()) {
-        m_wholeSubtreeInvalid = true;
-        return;
-    }
     m_invalidationSets.append(&invalidationSet);
     m_invalidateCustomPseudo = invalidationSet.customPseudoInvalid();
 }
 
 ALWAYS_INLINE bool StyleInvalidator::RecursionData::matchesCurrentInvalidationSets(Element& element)
 {
-    ASSERT(!m_wholeSubtreeInvalid);
-
     if (m_invalidateCustomPseudo && element.shadowPseudoId() != nullAtom) {
         TRACE_STYLE_INVALIDATOR_INVALIDATION_IF_ENABLED(element, InvalidateCustomPseudo);
         return true;
     }
 
     if (m_insertionPointCrossing && element.isInsertionPoint())
         return true;
 
     for (const auto& invalidationSet : m_invalidationSets) {
         if (invalidationSet->invalidatesElement(element))
@@ skipping 49 matching lines @@
 {
     RecursionCheckpoint checkpoint(&recursionData);
 
     bool thisElementNeedsStyleRecalc = checkInvalidationSetsAgainstElement(element, recursionData);
 
     bool someChildrenNeedStyleRecalc = false;
     if (recursionData.hasInvalidationSets() || element.childNeedsStyleInvalidation())
         someChildrenNeedStyleRecalc = invalidateChildren(element, recursionData);
 
     if (thisElementNeedsStyleRecalc) {
-        element.setNeedsStyleRecalc(recursionData.wholeSubtreeInvalid() ? SubtreeStyleChange : LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
+        ASSERT(!recursionData.wholeSubtreeInvalid());
+        element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
     } else if (recursionData.hasInvalidationSets() && someChildrenNeedStyleRecalc) {
         // Clone the LayoutStyle in order to preserve correct style sharing, if possible. Otherwise recalc style.
         if (LayoutObject* renderer = element.renderer()) {
             renderer->setStyleInternal(LayoutStyle::clone(renderer->styleRef()));
         } else {
             TRACE_STYLE_INVALIDATOR_INVALIDATION_IF_ENABLED(element, PreventStyleSharingForParent);
             element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
         }
     }
 
     if (recursionData.insertionPointCrossing() && element.isInsertionPoint())
         element.setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
 
     element.clearChildNeedsStyleInvalidation();
     element.clearNeedsStyleInvalidation();
 
     return thisElementNeedsStyleRecalc;
 }
 
 void StyleInvalidator::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_pendingInvalidationMap);
 #endif
 }
 
 } // namespace blink