Implemented scoped invalidation for added/removed RuleSets.

third_party/WebKit/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 28 matching lines @@
 #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/StyleChangeReason.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/HTMLSlotElement.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/page/Page.h"
 #include "core/svg/SVGStyleElement.h"
 #include "platform/TraceEvent.h"
 #include "platform/fonts/FontCache.h"
 
 namespace blink {
 
 using namespace HTMLNames;
@@ skipping 683 matching lines @@
         scheduleSiblingInvalidationsForElement(*beforeElement, *schedulingParent, i);
 }
 
 void StyleEngine::scheduleNthPseudoInvalidations(ContainerNode& nthParent)
 {
     InvalidationLists invalidationLists;
     ensureResolver().ensureUpdatedRuleFeatureSet().collectNthInvalidationSet(invalidationLists);
     m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists, nthParent);
 }
 
+void StyleEngine::scheduleRuleSetInvalidationsForElement(Element& element, const HeapVector<Member<const RuleSet>>& ruleSets)
+{
+    AtomicString id;
+    const SpaceSplitString* classNames = nullptr;
+
+    if (element.hasID())
+        id = element.idForStyleResolution();
+    if (element.hasClass())
+        classNames = &element.classNames();
+
+    InvalidationLists invalidationLists;
+    for (const auto& ruleSet : ruleSets) {
+        if (!id.isNull())
+            ruleSet->features().collectInvalidationSetsForId(invalidationLists, element, id);
+        if (classNames) {
+            unsigned classNameCount = classNames->size();
+            for (size_t i = 0; i < classNameCount; i++)
+                ruleSet->features().collectInvalidationSetsForClass(invalidationLists, element, (*classNames)[i]);
+        }
+        for (const Attribute& attribute : element.attributes())
+            ruleSet->features().collectInvalidationSetsForAttribute(invalidationLists, element, attribute.name());
+        if (ruleSet->tagRules(element.localNameForSelectorMatching()))
+            element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
+    }
+    m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists, element);
+}
+
+void StyleEngine::invalidateSlottedElements(HTMLSlotElement& slot)
+{
+    for (auto& node : slot.getDistributedNodes()) {
+        if (node->isElementNode())
+            node->setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
+    }
+}
+
+void StyleEngine::scheduleInvalidationsForRuleSets(TreeScope& treeScope, const HeapVector<Member<const RuleSet>>& ruleSets)
+{
+#if DCHECK_IS_ON()
+    // Full scope recalcs should be handled while collecting the ruleSets before
+    // calling this method.
+    for (auto ruleSet : ruleSets)
+        DCHECK(!ruleSet->features().needsFullRecalcForRuleSetInvalidation());
+#endif // DCHECK_IS_ON()
+
+    bool invalidateSlotted = false;
+    if (treeScope.rootNode().isShadowRoot()) {
+        Element& host = toShadowRoot(treeScope.rootNode()).host();
+        scheduleRuleSetInvalidationsForElement(host, ruleSets);
+        if (host.getStyleChangeType() >= SubtreeStyleChange)
+            return;
+        for (auto ruleSet : ruleSets) {
+            if (ruleSet->hasSlottedRules()) {
+                invalidateSlotted = true;
+                break;
+            }
+        }
+    }
+
+    Node* stayWithin = &treeScope.rootNode();
+    Element* element = ElementTraversal::firstChild(*stayWithin);
+    while (element) {
+        scheduleRuleSetInvalidationsForElement(*element, ruleSets);
+        if (invalidateSlotted && isHTMLSlotElement(element))
+            invalidateSlottedElements(toHTMLSlotElement(*element));
+
+        if (element->getStyleChangeType() < SubtreeStyleChange)
+            element = ElementTraversal::next(*element, stayWithin);
+        else
+            element = ElementTraversal::nextSkippingChildren(*element, stayWithin);
+    }
+}
+
 void StyleEngine::setStatsEnabled(bool enabled)
 {
     if (!enabled) {
         m_styleResolverStats = nullptr;
         return;
     }
     if (!m_styleResolverStats)
         m_styleResolverStats = StyleResolverStats::create();
     else
         m_styleResolverStats->reset();
@@ skipping 74 matching lines @@
 
 DEFINE_TRACE_WRAPPERS(StyleEngine)
 {
     for (auto sheet : m_injectedAuthorStyleSheets) {
         visitor->traceWrappers(sheet);
     }
     visitor->traceWrappers(m_documentStyleSheetCollection);
 }
 
 } // namespace blink