Sibling invalidation sets

Source/core/dom/StyleEngine.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 18 matching lines @@
 #include "core/dom/StyleEngine.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/FontFaceCache.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/resolver/ScopedStyleResolver.h"
 #include "core/dom/DocumentStyleSheetCollector.h"
 #include "core/dom/Element.h"
+#include "core/dom/ElementTraversal.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/dom/ShadowTreeStyleSheetCollection.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/page/Page.h"
 #include "core/svg/SVGStyleElement.h"
@@ skipping 572 matching lines @@
 void StyleEngine::platformColorsChanged()
 {
     if (m_resolver)
         m_resolver->invalidateMatchedPropertiesCache();
     document().setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::PlatformColorChange));
 }
 
 void StyleEngine::classChangedForElement(const SpaceSplitString& changedClasses, Element& element)
 {
     ASSERT(isMaster());
-    InvalidationSetVector invalidationSets;
+    InvalidationSetVector descendant, sibling;
     unsigned changedSize = changedClasses.size();
     RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
     for (unsigned i = 0; i < changedSize; ++i)
-        ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, changedClasses[i]);
-    scheduleInvalidationSetsForElement(invalidationSets, element);
+        ruleFeatureSet.collectInvalidationSetsForClass(descendant, sibling, element, changedClasses[i]);
+    m_styleInvalidator.scheduleInvalidationSetsForElement(descendant, sibling, element);
 }
 
 void StyleEngine::classChangedForElement(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, Element& element)
 {
     ASSERT(isMaster());
-    InvalidationSetVector invalidationSets;
     if (!oldClasses.size()) {
         classChangedForElement(newClasses, element);
         return;
     }
 
     // Class vectors tend to be very short. This is faster than using a hash table.
     BitVector remainingClassBits;
     remainingClassBits.ensureSize(oldClasses.size());
 
+    InvalidationSetVector descendant, sibling;
     RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
 
     for (unsigned i = 0; i < newClasses.size(); ++i) {
         bool found = false;
         for (unsigned j = 0; j < oldClasses.size(); ++j) {
             if (newClasses[i] == oldClasses[j]) {
                 // Mark each class that is still in the newClasses so we can skip doing
                 // an n^2 search below when looking for removals. We can't break from
                 // this loop early since a class can appear more than once.
                 remainingClassBits.quickSet(j);
                 found = true;
             }
         }
         // Class was added.
         if (!found)
-            ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, newClasses[i]);
+            ruleFeatureSet.collectInvalidationSetsForClass(descendant, sibling, element, newClasses[i]);
     }
 
     for (unsigned i = 0; i < oldClasses.size(); ++i) {
         if (remainingClassBits.quickGet(i))
             continue;
         // Class was removed.
-        ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, oldClasses[i]);
+        ruleFeatureSet.collectInvalidationSetsForClass(descendant, sibling, element, oldClasses[i]);
     }
 
-    scheduleInvalidationSetsForElement(invalidationSets, element);
+    m_styleInvalidator.scheduleInvalidationSetsForElement(descendant, sibling, element);
 }
 
 void StyleEngine::attributeChangedForElement(const QualifiedName& attributeName, Element& element)
 {
     ASSERT(isMaster());
-    InvalidationSetVector invalidationSets;
-    ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForAttribute(invalidationSets, element, attributeName);
-    scheduleInvalidationSetsForElement(invalidationSets, element);
+    InvalidationSetVector descendant, sibling;
+    ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForAttribute(descendant, sibling, element, attributeName);
+    m_styleInvalidator.scheduleInvalidationSetsForElement(descendant, sibling, element);
 }
 
 void StyleEngine::idChangedForElement(const AtomicString& oldId, const AtomicString& newId, Element& element)
 {
     ASSERT(isMaster());
-    InvalidationSetVector invalidationSets;
+    InvalidationSetVector descendant, sibling;
     RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet();
     if (!oldId.isEmpty())
-        ruleFeatureSet.collectInvalidationSetsForId(invalidationSets, element, oldId);
+        ruleFeatureSet.collectInvalidationSetsForId(descendant, sibling, element, oldId);
     if (!newId.isEmpty())
-        ruleFeatureSet.collectInvalidationSetsForId(invalidationSets, element, newId);
-    scheduleInvalidationSetsForElement(invalidationSets, element);
+        ruleFeatureSet.collectInvalidationSetsForId(descendant, sibling, element, newId);
+    m_styleInvalidator.scheduleInvalidationSetsForElement(descendant, sibling, element);
 }
 
 void StyleEngine::pseudoStateChangedForElement(CSSSelector::PseudoType pseudoType, Element& element)
 {
     ASSERT(isMaster());
-    InvalidationSetVector invalidationSets;
-    ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForPseudoClass(invalidationSets, element, pseudoType);
-    scheduleInvalidationSetsForElement(invalidationSets, element);
-}
-
-void StyleEngine::scheduleInvalidationSetsForElement(const InvalidationSetVector& invalidationSets, Element& element)
-{
-    for (auto invalidationSet : invalidationSets)
-        m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
+    InvalidationSetVector descendant, sibling;
+    ensureResolver().ensureUpdatedRuleFeatureSet().collectInvalidationSetsForPseudoClass(descendant, sibling, element, pseudoType);
+    m_styleInvalidator.scheduleInvalidationSetsForElement(descendant, sibling, element);
 }
 
 DEFINE_TRACE(StyleEngine)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_document);
     visitor->trace(m_authorStyleSheets);
     visitor->trace(m_documentStyleSheetCollection);
     visitor->trace(m_styleSheetCollectionMap);
     visitor->trace(m_resolver);
     visitor->trace(m_styleInvalidator);
     visitor->trace(m_dirtyTreeScopes);
     visitor->trace(m_activeTreeScopes);
     visitor->trace(m_fontSelector);
     visitor->trace(m_textToSheetCache);
     visitor->trace(m_sheetToTextCache);
 #endif
     CSSFontSelectorClient::trace(visitor);
 }
 
 }