Fixed ::slotted performance in pure v1 shadow documents.

third_party/WebKit/Source/core/css/resolver/StyleResolver.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, 2013 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 63 matching lines @@
 #include "core/dom/FirstLetterPseudoElement.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/Text.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLIFrameElement.h"
+#include "core/html/HTMLSlotElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/GeneratedChildren.h"
 #include "core/layout/LayoutView.h"
 #include "core/style/StyleVariableData.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGElement.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/StdLibExtras.h"
 
 namespace {
@@ skipping 330 matching lines @@
             continue;
         if (ScopedStyleResolver* resolver = shadowRoot->scopedStyleResolver()) {
             collector.clearMatchedRules();
             resolver->collectMatchingShadowHostRules(collector);
             collector.sortAndTransferMatchedRules();
             collector.finishAddingAuthorRulesForTreeScope();
         }
     }
 }
 
+static void matchSlottedRules(const Element& element, ElementRuleCollector& collector)
+{
+    HTMLSlotElement* slot = element.assignedSlot();
+    if (!slot)
+        return;
+
+    HeapVector<Member<ScopedStyleResolver>> resolvers;
+    for (; slot; slot = slot->assignedSlot()) {
+        if (ScopedStyleResolver* resolver = slot->treeScope().scopedStyleResolver())
+            resolvers.append(resolver);
+    }
+    for (auto it = resolvers.rbegin(); it != resolvers.rend(); ++it) {
+        collector.clearMatchedRules();
+        (*it)->collectMatchingTreeBoundaryCrossingRules(collector);
+        collector.sortAndTransferMatchedRules();
+        collector.finishAddingAuthorRulesForTreeScope();
+    }
+}
+
 static void matchElementScopeRules(const Element& element, ScopedStyleResolver* elementScopeResolver, ElementRuleCollector& collector)
 {
     if (elementScopeResolver) {
         collector.clearMatchedRules();
         elementScopeResolver->collectMatchingAuthorRules(collector);
         elementScopeResolver->collectMatchingTreeBoundaryCrossingRules(collector);
         collector.sortAndTransferMatchedRules();
     }
 
     if (element.isStyledElement() && element.inlineStyle() && !collector.isCollectingForPseudoElement()) {
@@ skipping 31 matching lines @@
 
 void StyleResolver::matchScopedRules(const Element& element, ElementRuleCollector& collector)
 {
     // Match rules from treeScopes in the reverse tree-of-trees order, since the
     // cascading order for normal rules is such that when comparing rules from
     // different shadow trees, the rule from the tree which comes first in the
     // tree-of-trees order wins. From other treeScopes than the element's own
     // scope, only tree-boundary-crossing rules may match.
 
     ScopedStyleResolver* elementScopeResolver = scopedResolverFor(element);
+
+    if (!document().styleEngine().mayContainV0Shadow()) {
+        matchSlottedRules(element, collector);
+        matchElementScopeRules(element, elementScopeResolver, collector);
+        return;
+    }
+
     bool matchElementScopeDone = !elementScopeResolver && !element.inlineStyle();
 
-    // TODO(kochi): This loops through m_treeBoundaryCrossingScopes because to handle
-    // Shadow DOM V0 documents as well. In pure V1 document only have to go through
-    // the chain of scopes for assigned slots. Add fast path for pure V1 document.
     for (auto it = m_treeBoundaryCrossingScopes.rbegin(); it != m_treeBoundaryCrossingScopes.rend(); ++it) {
         const TreeScope& scope = (*it)->treeScope();
         ScopedStyleResolver* resolver = scope.scopedStyleResolver();
         ASSERT(resolver);
 
         bool isInnerTreeScope = element.treeScope().isInclusiveAncestorOf(scope);
         if (!shouldCheckScope(element, **it, isInnerTreeScope))
             continue;
 
         if (!matchElementScopeDone && scope.isInclusiveAncestorOf(element.treeScope())) {
@@ skipping 1212 matching lines @@
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingScopes);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink