Skip scheduling sibling invalidation based on direct adjacent count.

third_party/WebKit/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 716 matching lines @@
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, classChange, className);
         invalidationLists.descendants.append(descendants);
     }
 
     if (siblings) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, classChange, className);
         invalidationLists.siblings.append(siblings);
     }
 }
 
-void RuleFeatureSet::collectSiblingInvalidationSetForClass(InvalidationLists& invalidationLists, Element& element, const AtomicString& className) const
+void RuleFeatureSet::collectSiblingInvalidationSetForClass(InvalidationLists& invalidationLists, Element& element, const AtomicString& className, unsigned minDirectAdjacent) const
 {
     InvalidationSetMap::const_iterator it = m_classInvalidationSets.find(className);
     if (it == m_classInvalidationSets.end())
         return;
 
     InvalidationSet* invalidationSet = it->value.get();
     if (invalidationSet->type() == InvalidateDescendants)
         return;
 
     SiblingInvalidationSet* siblingSet = toSiblingInvalidationSet(invalidationSet);
+    if (siblingSet->maxDirectAdjacentSelectors() < minDirectAdjacent)
+        return;
+
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, classChange, className);
     invalidationLists.siblings.append(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForId(InvalidationLists& invalidationLists, Element& element, const AtomicString& id) const
 {
     InvalidationSetMap::const_iterator it = m_idInvalidationSets.find(id);
     if (it == m_idInvalidationSets.end())
         return;
 
     DescendantInvalidationSet* descendants;
     SiblingInvalidationSet* siblings;
     extractInvalidationSets(it->value.get(), descendants, siblings);
 
     if (descendants) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, idChange, id);
         invalidationLists.descendants.append(descendants);
     }
 
     if (siblings) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, idChange, id);
         invalidationLists.siblings.append(siblings);
     }
 }
 
-void RuleFeatureSet::collectSiblingInvalidationSetForId(InvalidationLists& invalidationLists, Element& element, const AtomicString& id) const
+void RuleFeatureSet::collectSiblingInvalidationSetForId(InvalidationLists& invalidationLists, Element& element, const AtomicString& id, unsigned minDirectAdjacent) const
 {
     InvalidationSetMap::const_iterator it = m_idInvalidationSets.find(id);
     if (it == m_idInvalidationSets.end())
         return;
 
     InvalidationSet* invalidationSet = it->value.get();
     if (invalidationSet->type() == InvalidateDescendants)
         return;
 
     SiblingInvalidationSet* siblingSet = toSiblingInvalidationSet(invalidationSet);
+    if (siblingSet->maxDirectAdjacentSelectors() < minDirectAdjacent)
+        return;
+
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, idChange, id);
     invalidationLists.siblings.append(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForAttribute(InvalidationLists& invalidationLists, Element& element, const QualifiedName& attributeName) const
 {
     InvalidationSetMap::const_iterator it = m_attributeInvalidationSets.find(attributeName.localName());
     if (it == m_attributeInvalidationSets.end())
         return;
 
     DescendantInvalidationSet* descendants;
     SiblingInvalidationSet* siblings;
     extractInvalidationSets(it->value.get(), descendants, siblings);
 
     if (descendants) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, attributeChange, attributeName);
         invalidationLists.descendants.append(descendants);
     }
 
     if (siblings) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, attributeChange, attributeName);
         invalidationLists.siblings.append(siblings);
     }
 }
 
-void RuleFeatureSet::collectSiblingInvalidationSetForAttribute(InvalidationLists& invalidationLists, Element& element, const QualifiedName& attributeName) const
+void RuleFeatureSet::collectSiblingInvalidationSetForAttribute(InvalidationLists& invalidationLists, Element& element, const QualifiedName& attributeName, unsigned minDirectAdjacent) const
 {
     InvalidationSetMap::const_iterator it = m_attributeInvalidationSets.find(attributeName.localName());
     if (it == m_attributeInvalidationSets.end())
         return;
 
     InvalidationSet* invalidationSet = it->value.get();
     if (invalidationSet->type() == InvalidateDescendants)
         return;
 
     SiblingInvalidationSet* siblingSet = toSiblingInvalidationSet(invalidationSet);
+    if (siblingSet->maxDirectAdjacentSelectors() < minDirectAdjacent)
+        return;
+
     TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblingSet, attributeChange, attributeName);
     invalidationLists.siblings.append(siblingSet);
 }
 
 void RuleFeatureSet::collectInvalidationSetsForPseudoClass(InvalidationLists& invalidationLists, Element& element, CSSSelector::PseudoType pseudo) const
 {
     PseudoTypeInvalidationSetMap::const_iterator it = m_pseudoInvalidationSets.find(pseudo);
     if (it == m_pseudoInvalidationSets.end())
         return;
 
     DescendantInvalidationSet* descendants;
     SiblingInvalidationSet* siblings;
     extractInvalidationSets(it->value.get(), descendants, siblings);
 
     if (descendants) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *descendants, pseudoChange, pseudo);
         invalidationLists.descendants.append(descendants);
     }
 
     if (siblings) {
         TRACE_SCHEDULE_STYLE_INVALIDATION(element, *siblings, pseudoChange, pseudo);
         invalidationLists.siblings.append(siblings);
     }
 }
 
-void RuleFeatureSet::collectUniversalSiblingInvalidationSet(InvalidationLists& invalidationLists) const
+void RuleFeatureSet::collectUniversalSiblingInvalidationSet(InvalidationLists& invalidationLists, unsigned minDirectAdjacent) const
 {
-    if (m_universalSiblingInvalidationSet)
+    if (m_universalSiblingInvalidationSet && m_universalSiblingInvalidationSet->maxDirectAdjacentSelectors() >= minDirectAdjacent)
         invalidationLists.siblings.append(m_universalSiblingInvalidationSet);
 }
 
 SiblingInvalidationSet& RuleFeatureSet::ensureUniversalSiblingInvalidationSet()
 {
     if (!m_universalSiblingInvalidationSet)
         m_universalSiblingInvalidationSet = SiblingInvalidationSet::create(nullptr);
     return *m_universalSiblingInvalidationSet;
 }
 
 void RuleFeatureSet::addFeaturesToUniversalSiblingInvalidationSet(const InvalidationSetFeatures& siblingFeatures, const InvalidationSetFeatures& descendantFeatures)
 {
     SiblingInvalidationSet& universalSet = ensureUniversalSiblingInvalidationSet();
     addFeaturesToInvalidationSet(universalSet, siblingFeatures);
     universalSet.updateMaxDirectAdjacentSelectors(siblingFeatures.maxDirectAdjacentSelectors);
 
     if (&siblingFeatures == &descendantFeatures)
         universalSet.setInvalidatesSelf();
     else
         addFeaturesToInvalidationSet(universalSet.ensureSiblingDescendants(), descendantFeatures);
 }
 
 DEFINE_TRACE(RuleFeatureSet)
 {
     visitor->trace(siblingRules);
     visitor->trace(uncommonAttributeRules);
 }
 
 } // namespace blink