Refactor SelectorChecker::BehaviorAtBoundary

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 60 matching lines @@
     ShadowRoot* root = element->containingShadowRoot();
     if (!root || root->type() != ShadowRoot::UserAgentShadowRoot)
         return false;
 
     if (element->shadowPseudoId() != selector.value())
         return false;
 
     return true;
 }
 
-Element* SelectorChecker::parentElement(const SelectorCheckingContext& context, bool allowToCrossBoundary) const
+static Element* parentElement(const SelectorChecker::SelectorCheckingContext& context)
 {
-    // CrossesBoundary means we don't care any context.scope. So we can walk up from a shadow root to its shadow host.
-    if (allowToCrossBoundary)
+    // If context.scope is a shadow root, we should walk up to its shadow host.
+    if (context.scope && context.scope == context.element->containingShadowRoot())

[esprehn, 2014/06/27 08:05:51]

Why don't we need the ScopeIsShadowRoot stuff anymore?

[kochi, 2014/06/30 02:44:06]

The flag used to mean that a context's scope was shadow *host*
(i.e. it pointed to the host element, instead of shadow *root*),
because it was needed to discriminate a scope of its shadow root
child from a scope of its own (<style scoped>).
Now <style scoped> is gone, and scope points to its shadow root,
we can tell a scope is shadow or not by just checking whether
a context's scope is shadow root or not, and we do not need the
flag any more.

         return context.element->parentOrShadowHostElement();
 
-    // If context.scope is a shadow root, we should walk up to its shadow host.
-    if ((context.behaviorAtBoundary & SelectorChecker::ScopeIsShadowRoot) && context.scope == context.element->containingShadowRoot())
-        return context.element->parentOrShadowHostElement();
-
-    if ((context.behaviorAtBoundary & SelectorChecker::BoundaryBehaviorMask) != SelectorChecker::StaysWithinTreeScope)

[esprehn, 2014/06/27 08:05:51]

Why is this not needed now?

[kochi, 2014/06/30 02:44:06]

Now the condition will never be met.

This condition used to mean that the code should not cross
tree scope boundary (e.g. shadow root -> shadow host, which used
to be in the same |context.scope| but in different treescopes)
but now a shadow root and its shadow host stays in a different
|context.scope| and we do not need this condition any more.
(and context.scope and treescope can/will be cleaned up later)

-        return context.element->parentElement();
-
     // If context.scope is some element in some shadow tree and querySelector initialized the context,
     // e.g. shadowRoot.querySelector(':host *'),
     // (a) context.element has the same treescope as context.scope, need to walk up to its shadow host.
     // (b) Otherwise, should not walk up from a shadow root to a shadow host.
     if (context.scope && context.scope->treeScope() == context.element->treeScope())
         return context.element->parentOrShadowHostElement();
 
     return context.element->parentElement();
 }
 
-bool SelectorChecker::scopeContainsLastMatchedElement(const SelectorCheckingContext& context) const
+static bool scopeContainsLastMatchedElement(const SelectorChecker::SelectorCheckingContext& context)
 {
-    if (!(context.behaviorAtBoundary & SelectorChecker::ScopeContainsLastMatchedElement))
+    if (!(context.contextFlags & SelectorChecker::ScopeContainsLastMatchedElement))
         return true;
 
     ASSERT(context.scope);
-    // If behaviorAtBoundary is not ScopeIsShadowRoot, we can use "contains".
-    if (!(context.behaviorAtBoundary & SelectorChecker::ScopeIsShadowRoot))
+    // If the scope is not a Shadow root, we can use "contains".
+    if (!context.scope->isShadowRoot())
         return context.scope->contains(context.element);
 
     // If a given element is scope, i.e. shadow host, matches.
     if (context.element == context.scope->shadowHost() && (!context.previousElement || context.previousElement->isInDescendantTreeOf(context.element)))
         return true;
 
-    ShadowRoot* root = context.element->containingShadowRoot();
-    if (!root)
-        return false;
-
-    // If a host of the containing shadow root is scope, matches.
-    return root == context.scope;
+    // If the containing shadow root is scope, matches.
+    return context.element->containingShadowRoot() == context.scope;
 }
 
 static inline bool nextSelectorExceedsScope(const SelectorChecker::SelectorCheckingContext& context)
 {
     if (context.scope && context.scope->isInShadowTree())
         return context.element == context.scope->shadowHost();
 
     return false;
 }
 
@@ skipping 200 matching lines @@
         for (; nextContext.element; nextContext.element = ElementTraversal::previousSibling(*nextContext.element)) {
             Match match = this->match(nextContext, siblingTraversalStrategy, 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() && (context.behaviorAtBoundary & BoundaryBehaviorMask) != StaysWithinTreeScope)
+            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);
         }
 
     case CSSSelector::ShadowDeep:
         {
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
-            for (nextContext.element = parentElement(context, true); nextContext.element; nextContext.element = parentElement(nextContext, true)) {
+            for (nextContext.element = context.element->parentOrShadowHostElement(); nextContext.element; nextContext.element = nextContext.element->parentOrShadowHostElement()) {
                 Match match = this->match(nextContext, siblingTraversalStrategy, 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
 {
     ASSERT(element);
     WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
-
-    const ContainerNode* scope = nextContext.scope;
-    BehaviorAtBoundary behaviorAtBoundary = nextContext.behaviorAtBoundary;
-
     collectDestinationInsertionPoints(*element, insertionPoints);
     for (size_t i = 0; i < insertionPoints.size(); ++i) {
         nextContext.element = insertionPoints[i];
-
-        // If a given scope is a shadow host of an insertion point but behaviorAtBoundary doesn't have ScopeIsShadowRoot,
-        // we need to update behaviorAtBoundary to make selectors like ":host > ::content" work correctly.
-        if (m_mode == SharingRules) {
-            nextContext.behaviorAtBoundary = static_cast<BehaviorAtBoundary>(behaviorAtBoundary | ScopeIsShadowRoot);
+        if (m_mode == SharingRules)
             nextContext.scope = insertionPoints[i]->containingShadowRoot();
-        } else if (scope == insertionPoints[i]->containingShadowRoot() && !(behaviorAtBoundary & ScopeIsShadowRoot)) {
-            nextContext.behaviorAtBoundary = static_cast<BehaviorAtBoundary>(behaviorAtBoundary | ScopeIsShadowRoot);
-        } else {
-            nextContext.behaviorAtBoundary = behaviorAtBoundary;
-        }
-
         nextContext.isSubSelector = false;
         nextContext.elementStyle = 0;
         if (match(nextContext, siblingTraversalStrategy, result) == SelectorMatches)
             return SelectorMatches;
     }
     return SelectorFailsLocally;
 }
 
 template<typename CharType>
 static inline bool containsHTMLSpaceTemplate(const CharType* string, unsigned length)
@@ skipping 115 matching lines @@
 }
 
 template<typename SiblingTraversalStrategy>
 bool SelectorChecker::checkOne(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, unsigned* specificity) const
 {
     ASSERT(context.element);
     Element& element = *context.element;
     ASSERT(context.selector);
     const CSSSelector& selector = *context.selector;
 
-    bool elementIsHostInItsShadowTree = isHostInItsShadowTree(element, context.behaviorAtBoundary, context.scope);
+    bool elementIsHostInItsShadowTree = isHostInItsShadowTree(element, context.scope);
 
     // Only :host and :ancestor should match the host: http://drafts.csswg.org/css-scoping/#host-element
     if (elementIsHostInItsShadowTree && !selector.isHostPseudoClass()
-        && !(context.behaviorAtBoundary & TreatShadowHostAsNormalScope))
+        && !(context.contextFlags & TreatShadowHostAsNormalScope))
         return false;
 
     if (selector.match() == CSSSelector::Tag)
         return SelectorChecker::tagMatches(element, selector.tagQName());
 
     if (selector.match() == CSSSelector::Class)
         return element.hasClass() && element.classNames().contains(selector.value());
 
     if (selector.match() == CSSSelector::Id)
         return element.hasID() && element.idForStyleResolution() == selector.value();
@@ skipping 388 matching lines @@
                     return true;
 
                 SelectorCheckingContext subContext(context);
                 subContext.isSubSelector = true;
 
                 bool matched = false;
                 unsigned maxSpecificity = 0;
 
                 // 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.behaviorAtBoundary = ScopeIsShadowHostInPseudoHostParameter;
+                    subContext.contextFlags = TreatShadowHostAsNormalScope;
                     subContext.scope = context.scope;
                     // Use NodeRenderingTraversal 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) {
                             matched = true;
                             // Consider div:host(div:host(div:host(div:host...))).
                             maxSpecificity = std::max(maxSpecificity, hostContext.selector->specificity() + subResult.specificity);
                             break;
                         }
-                        hostContext.behaviorAtBoundary = DoesNotCrossBoundary;
+                        hostContext.contextFlags = DefaultBehavior;
                         hostContext.scope = 0;
 
                         if (selector.pseudoType() == CSSSelector::PseudoHost)
                             break;
 
                         hostContext.elementStyle = 0;
                         nextElement = NodeRenderingTraversal::parentElement(nextElement);
                     } while (nextElement);
                 }
                 if (matched) {
@@ skipping 19 matching lines @@
         case CSSSelector::PseudoUnknown:
         case CSSSelector::PseudoNotParsed:
         default:
             ASSERT_NOT_REACHED();
             break;
         }
         return false;
     } else if (selector.match() == CSSSelector::PseudoElement && selector.pseudoType() == CSSSelector::PseudoCue) {
         SelectorCheckingContext subContext(context);
         subContext.isSubSelector = true;
-        subContext.behaviorAtBoundary = StaysWithinTreeScope;
+        subContext.contextFlags = DefaultBehavior;
 
         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)
                 return true;
         }
         return false;
     }
     // ### add the rest of the checks...
@@ skipping 135 matching lines @@
     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;
 
 }