Remove support for pseudo classes in <content select>.

Source/core/css/SelectorChecker.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 142 matching lines @@
         return true;
     return context.element->isLink();
 }
 
 // Recursive check of selectors and combinators
 // It can return 4 different values:
 // * SelectorMatches          - the selector matches the element e
 // * SelectorFailsLocally     - the selector fails for the element e
 // * SelectorFailsAllSiblings - the selector fails for e and any sibling of e
 // * SelectorFailsCompletely  - the selector fails for e and any sibling or ancestor of e
-template<typename SiblingTraversalStrategy>
-SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
+SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext& context, MatchResult* result) const
 {
     // first selector has to match
     unsigned specificity = 0;
-    if (!checkOne(context, siblingTraversalStrategy, &specificity))
+    if (!checkOne(context, &specificity))
         return SelectorFailsLocally;
 
     if (context.selector->match() == CSSSelector::PseudoElement) {
         if (context.selector->isCustomPseudoElement()) {
             if (!matchesCustomPseudoElement(context.element, *context.selector))
                 return SelectorFailsLocally;
         } else if (context.selector->isContentPseudoElement()) {
             if (!context.element->isInShadowTree() || !context.element->isInsertionPoint())
                 return SelectorFailsLocally;
         } else if (context.selector->isShadowPseudoElement()) {
@@ skipping 26 matching lines @@
         // Abort if the next selector would exceed the scope.
         if (nextSelectorExceedsScope(context))
             return SelectorFailsCompletely;
 
         // Bail-out if this selector is irrelevant for the pseudoId
         if (context.pseudoId != NOPSEUDO && (!result || context.pseudoId != result->dynamicPseudo))
             return SelectorFailsCompletely;
 
         if (result) {
             TemporaryChange<PseudoId> dynamicPseudoScope(result->dynamicPseudo, NOPSEUDO);
-            match = matchForRelation(context, siblingTraversalStrategy, result);
+            match = matchForRelation(context, result);
         } else {
-            return matchForRelation(context, siblingTraversalStrategy, 0);
+            return matchForRelation(context, 0);
         }
     } else {
-        match = matchForSubSelector(context, siblingTraversalStrategy, result);
+        match = matchForSubSelector(context, result);
     }
     if (match != SelectorMatches || !result)
         return match;
 
     result->specificity += specificity;
     return SelectorMatches;
 }
 
 static inline SelectorChecker::SelectorCheckingContext prepareNextContextForRelation(const SelectorChecker::SelectorCheckingContext& context)
 {
     SelectorChecker::SelectorCheckingContext nextContext(context);
     ASSERT(context.selector->tagHistory());
     nextContext.selector = context.selector->tagHistory();
     return nextContext;
 }
 
 static inline bool isOpenShadowRoot(const Node* node)
 {
     return node && node->isShadowRoot() && toShadowRoot(node)->type() == ShadowRoot::OpenShadowRoot;
 }
 
-template<typename SiblingTraversalStrategy>
-SelectorChecker::Match SelectorChecker::matchForSubSelector(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
+SelectorChecker::Match SelectorChecker::matchForSubSelector(const SelectorCheckingContext& context, MatchResult* result) const
 {
     SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
     PseudoId dynamicPseudo = result ? result->dynamicPseudo : NOPSEUDO;
     // a selector is invalid if something follows a pseudo-element
     // We make an exception for scrollbar pseudo elements and allow a set of pseudo classes (but nothing else)
     // to follow the pseudo elements.
     nextContext.hasScrollbarPseudo = dynamicPseudo != NOPSEUDO && (context.scrollbar || dynamicPseudo == SCROLLBAR_CORNER || dynamicPseudo == RESIZER);
     nextContext.hasSelectionPseudo = dynamicPseudo == SELECTION;
     if ((context.elementStyle || m_mode == CollectingCSSRules || m_mode == CollectingStyleRules || m_mode == QueryingRules) && dynamicPseudo != NOPSEUDO
         && !nextContext.hasSelectionPseudo
         && !(nextContext.hasScrollbarPseudo && nextContext.selector->match() == CSSSelector::PseudoClass))
         return SelectorFailsCompletely;
 
     nextContext.isSubSelector = true;
-    return match(nextContext, siblingTraversalStrategy, result);
+    return match(nextContext, result);
 }
 
 static bool selectorMatchesShadowRoot(const CSSSelector* selector)
 {
     return selector && selector->isShadowPseudoElement();
 }
 
 static inline Element* parentOrShadowHostButDisallowEscapingUserAgentShadowTree(const Element& element)
 {
     ContainerNode* parent = element.parentOrShadowHostNode();
     if (!parent)
         return nullptr;
     if (parent->isShadowRoot())
         return (toShadowRoot(parent)->type() == ShadowRoot::UserAgentShadowRoot) ? nullptr : toShadowRoot(parent)->host();
     if (!parent->isElementNode())
         return nullptr;
     return toElement(parent);
 }
 
-template<typename SiblingTraversalStrategy>
-SelectorChecker::Match SelectorChecker::matchForPseudoShadow(const ContainerNode* node, const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
+SelectorChecker::Match SelectorChecker::matchForPseudoShadow(const ContainerNode* node, const SelectorCheckingContext& context, MatchResult* result) const
 {
     if (!isOpenShadowRoot(node))
         return SelectorFailsCompletely;
-    return match(context, siblingTraversalStrategy, result);
+    return match(context, result);
 }
 
-template<typename SiblingTraversalStrategy>
-SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
+SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingContext& context, MatchResult* result) const
 {
     SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
     nextContext.previousElement = context.element;
 
     CSSSelector::Relation relation = context.selector->relation();
 
     // Disable :visited matching when we see the first link or try to match anything else than an ancestors.
     if (!context.isSubSelector && (context.element->isLink() || (relation != CSSSelector::Descendant && relation != CSSSelector::Child)))
         nextContext.visitedMatchType = VisitedMatchDisabled;
 
     nextContext.pseudoId = NOPSEUDO;
 
     switch (relation) {
     case CSSSelector::Descendant:
         if (context.selector->relationIsAffectedByPseudoContent()) {
             for (Element* element = context.element; element; element = element->parentElement()) {
-                if (matchForShadowDistributed(element, siblingTraversalStrategy, nextContext, result) == SelectorMatches)
+                if (matchForShadowDistributed(element, nextContext, result) == SelectorMatches)
                     return SelectorMatches;
             }
             return SelectorFailsCompletely;
         }
         nextContext.isSubSelector = false;
         nextContext.elementStyle = 0;
 
         if (selectorMatchesShadowRoot(nextContext.selector))
-            return matchForPseudoShadow(context.element->containingShadowRoot(), nextContext, siblingTraversalStrategy, result);
+            return matchForPseudoShadow(context.element->containingShadowRoot(), nextContext, result);
 
         for (nextContext.element = parentElement(context); nextContext.element; nextContext.element = parentElement(nextContext)) {
-            Match match = this->match(nextContext, siblingTraversalStrategy, result);
+            Match match = this->match(nextContext, result);
             if (match == SelectorMatches || match == SelectorFailsCompletely)
                 return match;
             if (nextSelectorExceedsScope(nextContext))
                 return SelectorFailsCompletely;
         }
         return SelectorFailsCompletely;
     case CSSSelector::Child:
         {
             if (context.selector->relationIsAffectedByPseudoContent())
-                return matchForShadowDistributed(context.element, siblingTraversalStrategy, nextContext, result);
+                return matchForShadowDistributed(context.element, nextContext, result);
 
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
 
             if (selectorMatchesShadowRoot(nextContext.selector))
-                return matchForPseudoShadow(context.element->parentNode(), nextContext, siblingTraversalStrategy, result);
+                return matchForPseudoShadow(context.element->parentNode(), nextContext, result);
 
             nextContext.element = parentElement(context);
             if (!nextContext.element)
                 return SelectorFailsCompletely;
-            return match(nextContext, siblingTraversalStrategy, result);
+            return match(nextContext, result);
         }
     case CSSSelector::DirectAdjacent:
         // Shadow roots can't have sibling elements
         if (selectorMatchesShadowRoot(nextContext.selector))
             return SelectorFailsCompletely;
 
         if (m_mode == ResolvingStyle) {
             if (ContainerNode* parent = context.element->parentElementOrShadowRoot())
                 parent->setChildrenAffectedByDirectAdjacentRules();
         }
         nextContext.element = ElementTraversal::previousSibling(*context.element);
         if (!nextContext.element)
             return SelectorFailsAllSiblings;
         nextContext.isSubSelector = false;
         nextContext.elementStyle = 0;
-        return match(nextContext, siblingTraversalStrategy, result);
+        return match(nextContext, result);
 
     case CSSSelector::IndirectAdjacent:
         // Shadow roots can't have sibling elements
         if (selectorMatchesShadowRoot(nextContext.selector))
             return SelectorFailsCompletely;
 
         if (m_mode == ResolvingStyle) {
             if (ContainerNode* parent = context.element->parentElementOrShadowRoot())
                 parent->setChildrenAffectedByIndirectAdjacentRules();
         }
         nextContext.element = ElementTraversal::previousSibling(*context.element);
         nextContext.isSubSelector = false;
         nextContext.elementStyle = 0;
         for (; nextContext.element; nextContext.element = ElementTraversal::previousSibling(*nextContext.element)) {
-            Match match = this->match(nextContext, siblingTraversalStrategy, result);
+            Match match = this->match(nextContext, result);
             if (match == SelectorMatches || match == SelectorFailsAllSiblings || match == SelectorFailsCompletely)
                 return match;
         };
         return SelectorFailsAllSiblings;
 
     case CSSSelector::ShadowPseudo:
         {
             // If we're in the same tree-scope as the scoping element, then following a shadow descendant combinator would escape that and thus the scope.
             if (context.scope && context.scope->shadowHost() && context.scope->shadowHost()->treeScope() == context.element->treeScope())
                 return SelectorFailsCompletely;
 
             Element* shadowHost = context.element->shadowHost();
             if (!shadowHost)
                 return SelectorFailsCompletely;
             nextContext.element = shadowHost;
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
-            return this->match(nextContext, siblingTraversalStrategy, result);
+            return this->match(nextContext, result);
         }
 
     case CSSSelector::ShadowDeep:
         {
             if (context.selector->relationIsAffectedByPseudoContent()) {
                 for (Element* element = context.element; element; element = parentOrShadowHostButDisallowEscapingUserAgentShadowTree(*element)) {
-                    if (matchForShadowDistributed(element, siblingTraversalStrategy, nextContext, result) == SelectorMatches)
+                    if (matchForShadowDistributed(element, nextContext, result) == SelectorMatches)
                         return SelectorMatches;
                 }
                 return SelectorFailsCompletely;
             }
 
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
             for (nextContext.element = parentOrShadowHostButDisallowEscapingUserAgentShadowTree(*context.element); nextContext.element; nextContext.element = parentOrShadowHostButDisallowEscapingUserAgentShadowTree(*nextContext.element)) {
-                Match match = this->match(nextContext, siblingTraversalStrategy, result);
+                Match match = this->match(nextContext, result);
                 if (match == SelectorMatches || match == SelectorFailsCompletely)
                     return match;
                 if (nextSelectorExceedsScope(nextContext))
                     return SelectorFailsCompletely;
             }
             return SelectorFailsCompletely;
         }
 
     case CSSSelector::SubSelector:
         ASSERT_NOT_REACHED();
     }
 
     ASSERT_NOT_REACHED();
     return SelectorFailsCompletely;
 }
 
-template<typename SiblingTraversalStrategy>
-SelectorChecker::Match SelectorChecker::matchForShadowDistributed(const Element* element, const SiblingTraversalStrategy& siblingTraversalStrategy, SelectorCheckingContext& nextContext, MatchResult* result) const
+SelectorChecker::Match SelectorChecker::matchForShadowDistributed(const Element* element, SelectorCheckingContext& nextContext, MatchResult* result) const
 {
     ASSERT(element);
     WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
     collectDestinationInsertionPoints(*element, insertionPoints);
     for (size_t i = 0; i < insertionPoints.size(); ++i) {
         nextContext.element = insertionPoints[i];
         if (m_mode == SharingRules)
             nextContext.scope = insertionPoints[i]->containingShadowRoot();
         nextContext.isSubSelector = false;
         nextContext.elementStyle = 0;
-        if (match(nextContext, siblingTraversalStrategy, result) == SelectorMatches)
+        if (match(nextContext, result) == SelectorMatches)
             return SelectorMatches;
     }
     return SelectorFailsLocally;
 }
 
 template<typename CharType>
 static inline bool containsHTMLSpaceTemplate(const CharType* string, unsigned length)
 {
     for (unsigned i = 0; i < length; ++i)
         if (isHTMLSpace<CharType>(string[i]))
@@ skipping 108 matching lines @@
             UseCounter::count(element.document(), UseCounter::CaseInsensitiveAttrSelectorMatch);
             return true;
         }
         if (selectorAttr.namespaceURI() != starAtom)
             return false;
     }
 
     return false;
 }
 
-template<typename SiblingTraversalStrategy>
-bool SelectorChecker::checkOne(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, unsigned* specificity) const
+bool SelectorChecker::checkOne(const SelectorCheckingContext& context, unsigned* specificity) const
 {
     ASSERT(context.element);
     Element& element = *context.element;
     ASSERT(context.selector);
     const CSSSelector& selector = *context.selector;
 
     // Only :host and :host-context() should match the host: http://drafts.csswg.org/css-scoping/#host-element
     if (context.scope && context.scope->shadowHost() == element && (!selector.isHostPseudoClass()
         && !context.treatShadowHostAsNormalScope
         && selector.match() != CSSSelector::PseudoElement))
@@ skipping 11 matching lines @@
     case CSSSelector::AttributeExact:
     case CSSSelector::AttributeSet:
     case CSSSelector::AttributeHyphen:
     case CSSSelector::AttributeList:
     case CSSSelector::AttributeContain:
     case CSSSelector::AttributeBegin:
     case CSSSelector::AttributeEnd:
         return anyAttributeMatches(element, selector.match(), selector);
 
     case CSSSelector::PseudoClass:
-        return checkPseudoClass(context, siblingTraversalStrategy, specificity);
+        return checkPseudoClass(context, specificity);
     case CSSSelector::PseudoElement:
-        return checkPseudoElement(context, siblingTraversalStrategy);
+        return checkPseudoElement(context);
 
     case CSSSelector::PagePseudoClass:
         // FIXME: what?
         return true;
     case CSSSelector::Unknown:
         // FIXME: what?
         return true;
     }
     ASSERT_NOT_REACHED();
     return true;
 }
 
-template<typename SiblingTraversalStrategy>
-bool SelectorChecker::checkPseudoClass(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, unsigned* specificity) const
+bool SelectorChecker::checkPseudoClass(const SelectorCheckingContext& context, unsigned* specificity) const
 {
     Element& element = *context.element;
     const CSSSelector& selector = *context.selector;
 
     // Handle :not up front.
     if (selector.pseudoType() == CSSSelector::PseudoNot) {
         SelectorCheckingContext subContext(context);
         subContext.isSubSelector = true;
         ASSERT(selector.selectorList());
         for (subContext.selector = selector.selectorList()->first(); subContext.selector; subContext.selector = subContext.selector->tagHistory()) {
             // :not cannot nest. I don't really know why this is a
             // restriction in CSS3, but it is, so let's honor it.
             // the parser enforces that this never occurs
             ASSERT(subContext.selector->pseudoType() != CSSSelector::PseudoNot);
             // We select between :visited and :link when applying. We don't know which one applied (or not) yet.
             if (subContext.selector->pseudoType() == CSSSelector::PseudoVisited || (subContext.selector->pseudoType() == CSSSelector::PseudoLink && subContext.visitedMatchType == VisitedMatchEnabled))
                 return true;
             // context.scope is not available if m_mode == SharingRules.
             // We cannot determine whether :host or :scope matches a given element or not.
             if (m_mode == SharingRules && (subContext.selector->isHostPseudoClass() || subContext.selector->pseudoType() == CSSSelector::PseudoScope))
                 return true;
-            if (!checkOne(subContext, siblingTraversalStrategy))
+            if (!checkOne(subContext))
                 return true;
         }
         return false;
     }
 
     if (context.hasScrollbarPseudo) {
         // CSS scrollbars match a specific subset of pseudo classes, and they have specialized rules for each
         // (since there are no elements involved).
         return checkScrollbarPseudoClass(context, &element.document(), selector);
     }
@@ skipping 31 matching lines @@
                     element.mutableComputedStyle()->setEmptyState(result);
             }
             return result;
         }
     case CSSSelector::PseudoFirstChild:
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle) {
                 parent->setChildrenAffectedByFirstChildRules();
                 element.setAffectedByFirstChildRules();
             }
-            return siblingTraversalStrategy.isFirstChild(element);
+            return DOMSiblingTraversalStrategy::isFirstChild(element);
         }
         break;
     case CSSSelector::PseudoFirstOfType:
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle)
                 parent->setChildrenAffectedByForwardPositionalRules();
-            return siblingTraversalStrategy.isFirstOfType(element, element.tagQName());
+            return DOMSiblingTraversalStrategy::isFirstOfType(element, element.tagQName());
         }
         break;
     case CSSSelector::PseudoLastChild:
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle) {
                 parent->setChildrenAffectedByLastChildRules();
                 element.setAffectedByLastChildRules();
             }
             if (!parent->isFinishedParsingChildren())
                 return false;
-            return siblingTraversalStrategy.isLastChild(element);
+            return DOMSiblingTraversalStrategy::isLastChild(element);
         }
         break;
     case CSSSelector::PseudoLastOfType:
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle)
                 parent->setChildrenAffectedByBackwardPositionalRules();
             if (!parent->isFinishedParsingChildren())
                 return false;
-            return siblingTraversalStrategy.isLastOfType(element, element.tagQName());
+            return DOMSiblingTraversalStrategy::isLastOfType(element, element.tagQName());
         }
         break;
     case CSSSelector::PseudoOnlyChild:
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle) {
                 parent->setChildrenAffectedByFirstChildRules();
                 parent->setChildrenAffectedByLastChildRules();
                 element.setAffectedByFirstChildRules();
                 element.setAffectedByLastChildRules();
             }
             if (!parent->isFinishedParsingChildren())
                 return false;
-            return siblingTraversalStrategy.isFirstChild(element) && siblingTraversalStrategy.isLastChild(element);
+            return DOMSiblingTraversalStrategy::isFirstChild(element) && DOMSiblingTraversalStrategy::isLastChild(element);
         }
         break;
     case CSSSelector::PseudoOnlyOfType:
         // FIXME: This selector is very slow.
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle) {
                 parent->setChildrenAffectedByForwardPositionalRules();
                 parent->setChildrenAffectedByBackwardPositionalRules();
             }
             if (!parent->isFinishedParsingChildren())
                 return false;
-            return siblingTraversalStrategy.isFirstOfType(element, element.tagQName()) && siblingTraversalStrategy.isLastOfType(element, element.tagQName());
+            return DOMSiblingTraversalStrategy::isFirstOfType(element, element.tagQName()) && DOMSiblingTraversalStrategy::isLastOfType(element, element.tagQName());
         }
         break;
     case CSSSelector::PseudoNthChild:
         if (!selector.parseNth())
             break;
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle)
                 parent->setChildrenAffectedByForwardPositionalRules();
-            return selector.matchNth(1 + siblingTraversalStrategy.countElementsBefore(element));
+            return selector.matchNth(1 + DOMSiblingTraversalStrategy::countElementsBefore(element));
         }
         break;
     case CSSSelector::PseudoNthOfType:
         if (!selector.parseNth())
             break;
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle)
                 parent->setChildrenAffectedByForwardPositionalRules();
-            return selector.matchNth(1 + siblingTraversalStrategy.countElementsOfTypeBefore(element, element.tagQName()));
+            return selector.matchNth(1 + DOMSiblingTraversalStrategy::countElementsOfTypeBefore(element, element.tagQName()));
         }
         break;
     case CSSSelector::PseudoNthLastChild:
         if (!selector.parseNth())
             break;
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle)
                 parent->setChildrenAffectedByBackwardPositionalRules();
             if (!parent->isFinishedParsingChildren())
                 return false;
-            return selector.matchNth(1 + siblingTraversalStrategy.countElementsAfter(element));
+            return selector.matchNth(1 + DOMSiblingTraversalStrategy::countElementsAfter(element));
         }
         break;
     case CSSSelector::PseudoNthLastOfType:
         if (!selector.parseNth())
             break;
         if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
             if (m_mode == ResolvingStyle)
                 parent->setChildrenAffectedByBackwardPositionalRules();
             if (!parent->isFinishedParsingChildren())
                 return false;
-            return selector.matchNth(1 + siblingTraversalStrategy.countElementsOfTypeAfter(element, element.tagQName()));
+            return selector.matchNth(1 + DOMSiblingTraversalStrategy::countElementsOfTypeAfter(element, element.tagQName()));
         }
         break;
     case CSSSelector::PseudoTarget:
         return element == element.document().cssTarget();
     case CSSSelector::PseudoAny:
         {
             SelectorCheckingContext subContext(context);
             subContext.isSubSelector = true;
             ASSERT(selector.selectorList());
             for (subContext.selector = selector.selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(*subContext.selector)) {
-                if (match(subContext, siblingTraversalStrategy) == SelectorMatches)
+                if (match(subContext) == SelectorMatches)
                     return true;
             }
         }
         break;
     case CSSSelector::PseudoAutofill:
         return element.isFormControlElement() && toHTMLFormControlElement(element).isAutofilled();
     case CSSSelector::PseudoAnyLink:
     case CSSSelector::PseudoLink:
         return element.isLink();
     case CSSSelector::PseudoVisited:
@@ skipping 132 matching lines @@
     case CSSSelector::PseudoScope:
         if (m_mode == SharingRules)
             return true;
         if (context.scope)
             return context.scope == element;
         return element == element.document().documentElement();
     case CSSSelector::PseudoUnresolved:
         return element.isUnresolvedCustomElement();
     case CSSSelector::PseudoHost:
     case CSSSelector::PseudoHostContext:
-        return checkPseudoHost(context, siblingTraversalStrategy, specificity);
+        return checkPseudoHost(context, specificity);
     case CSSSelector::PseudoSpatialNavigationFocus:
         return context.isUARule && matchesSpatialNavigationFocusPseudoClass(element);
     case CSSSelector::PseudoListBox:
         return context.isUARule && matchesListBoxPseudoClass(element);
     case CSSSelector::PseudoHorizontal:
     case CSSSelector::PseudoVertical:
     case CSSSelector::PseudoDecrement:
     case CSSSelector::PseudoIncrement:
     case CSSSelector::PseudoStart:
     case CSSSelector::PseudoEnd:
     case CSSSelector::PseudoDoubleButton:
     case CSSSelector::PseudoSingleButton:
     case CSSSelector::PseudoNoButton:
     case CSSSelector::PseudoCornerPresent:
     case CSSSelector::PseudoWindowInactive:
         return false;
     case CSSSelector::PseudoUnknown:
     case CSSSelector::PseudoNotParsed:
     default:
         ASSERT_NOT_REACHED();
         break;
     }
     return false;
 }
 
-template<typename SiblingTraversalStrategy>
-bool SelectorChecker::checkPseudoElement(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy) const
+bool SelectorChecker::checkPseudoElement(const SelectorCheckingContext& context) const
 {
     const CSSSelector& selector = *context.selector;
 
     if (selector.pseudoType() == CSSSelector::PseudoCue) {
         SelectorCheckingContext subContext(context);
         subContext.isSubSelector = true;
         subContext.scopeContainsLastMatchedElement = false;
         subContext.treatShadowHostAsNormalScope = false;
 
         const CSSSelector* contextSelector = context.selector;
         ASSERT(contextSelector);
         for (subContext.selector = contextSelector->selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(*subContext.selector)) {
-            if (match(subContext, siblingTraversalStrategy) == SelectorMatches)
+            if (match(subContext) == SelectorMatches)
                 return true;
         }
         return false;
     }
 
     // FIXME: this used to be a fallthrough condition.
     return true;
 }
 
-template<typename SiblingTraversalStrategy>
-bool SelectorChecker::checkPseudoHost(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, unsigned* specificity) const
+bool SelectorChecker::checkPseudoHost(const SelectorCheckingContext& context, unsigned* specificity) const
 {
     const CSSSelector& selector = *context.selector;
     Element& element = *context.element;
 
     if (m_mode == SharingRules)
         return true;
     // :host only matches a shadow host when :host is in a shadow tree of the shadow host.
     if (!context.scope)
         return false;
     const ContainerNode* shadowHost = context.scope->shadowHost();
@@ skipping 14 matching lines @@
     // If one of simple selectors matches an element, returns SelectorMatches. Just "OR".
     for (subContext.selector = selector.selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(*subContext.selector)) {
         subContext.treatShadowHostAsNormalScope = true;
         subContext.scope = context.scope;
         // Use ComposedTreeTraversal to traverse a composed ancestor list of a given element.
         Element* nextElement = &element;
         SelectorCheckingContext hostContext(subContext);
         do {
             MatchResult subResult;
             hostContext.element = nextElement;
-            if (match(hostContext, siblingTraversalStrategy, &subResult) == SelectorMatches) {
+            if (match(hostContext, &subResult) == SelectorMatches) {
                 matched = true;
                 // Consider div:host(div:host(div:host(div:host...))).
                 maxSpecificity = std::max(maxSpecificity, hostContext.selector->specificity() + subResult.specificity);
                 break;
             }
             hostContext.scopeContainsLastMatchedElement = false;
             hostContext.treatShadowHostAsNormalScope = false;
             hostContext.scope = nullptr;
 
             if (selector.pseudoType() == CSSSelector::PseudoHost)
@@ skipping 94 matching lines @@
     }
 }
 
 bool SelectorChecker::matchesFocusPseudoClass(const Element& element)
 {
     if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(&element), CSSSelector::PseudoFocus))
         return true;
     return element.focused() && isFrameFocused(element);
 }
 
-template
-SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, const DOMSiblingTraversalStrategy&, MatchResult*) const;
-
-template
-SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, const ShadowDOMSiblingTraversalStrategy&, MatchResult*) const;
-
 }