Schedule a type selector invalidation set for RuleSet invalidations.

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.
@@ skipping 814 matching lines @@
                                                        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::scheduleTypeRuleSetInvalidations(
+    ContainerNode& node,
+    const HeapHashSet<Member<RuleSet>>& ruleSets) {
+  InvalidationLists invalidationLists;
+  for (const auto& ruleSet : ruleSets)
+    ruleSet->features().collectTypeRuleInvalidationSet(invalidationLists, node);
+  DCHECK(invalidationLists.siblings.isEmpty());
+  m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists, node);
+}
+
 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 HeapHashSet<Member<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()
 
   TRACE_EVENT0("blink,blink_style",
                "StyleEngine::scheduleInvalidationsForRuleSets");
 
+  scheduleTypeRuleSetInvalidations(treeScope.rootNode(), ruleSets);
+
   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;
@@ skipping 270 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(StyleEngine) {
   for (auto sheet : m_injectedAuthorStyleSheets) {
     visitor->traceWrappers(sheet);
   }
   visitor->traceWrappers(m_documentStyleSheetCollection);
 }
 
 }  // namespace blink