Simplify some shadow crossing logic in SelectorQuery.cpp

third_party/WebKit/Source/core/dom/SelectorQuery.cpp

 /*
  * Copyright (C) 2011, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 376 matching lines @@
     if (selectorListMatches<SelectorQueryTrait>(rootNode, element, output) &&
         SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
 // FIXME: Move the following helper functions, authorShadowRootOf,
 // firstWithinTraversingShadowTree, nextTraversingShadowTree to the best place,
 // e.g. NodeTraversal.
 static ShadowRoot* authorShadowRootOf(const ContainerNode& node) {
-  if (!node.isElementNode() || !isShadowHost(&node))
+  if (!node.isElementNode())
+    return nullptr;
+  ElementShadow* shadow = toElement(node).shadow();
+  if (!shadow)
     return nullptr;
 
-  ElementShadow* shadow = toElement(node).shadow();
-  DCHECK(shadow);
   for (ShadowRoot* shadowRoot = &shadow->oldestShadowRoot(); shadowRoot;
        shadowRoot = shadowRoot->youngerShadowRoot()) {
-    if (shadowRoot->type() == ShadowRootType::V0 ||
-        shadowRoot->type() == ShadowRootType::Open)
+    if (shadowRoot->isOpenOrV0())
       return shadowRoot;
   }
   return nullptr;
 }
 
-static ContainerNode* firstWithinTraversingShadowTree(
-    const ContainerNode& rootNode) {
-  if (ShadowRoot* shadowRoot = authorShadowRootOf(rootNode))
-    return shadowRoot;
-  return ElementTraversal::firstWithin(rootNode);
-}
-
 static ContainerNode* nextTraversingShadowTree(const ContainerNode& node,
                                                const ContainerNode* rootNode) {
   if (ShadowRoot* shadowRoot = authorShadowRootOf(node))
     return shadowRoot;
 
   const ContainerNode* current = &node;
   while (current) {
     if (Element* next = ElementTraversal::next(*current, rootNode))
       return next;
 
     if (!current->isInShadowTree())
       return nullptr;
 
     ShadowRoot* shadowRoot = current->containingShadowRoot();
     if (shadowRoot == rootNode)
       return nullptr;
     if (ShadowRoot* youngerShadowRoot = shadowRoot->youngerShadowRoot()) {
-      // Should not obtain any elements in closed or user-agent shadow root.
-      DCHECK(youngerShadowRoot->type() == ShadowRootType::V0 ||
-             youngerShadowRoot->type() == ShadowRootType::Open);
+      DCHECK(youngerShadowRoot->isOpenOrV0());
       return youngerShadowRoot;
     }
 
     current = &shadowRoot->host();
   }
   return nullptr;
 }
 
 template <typename SelectorQueryTrait>
 void SelectorQuery::executeSlowTraversingShadowTree(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
-  for (ContainerNode* node = firstWithinTraversingShadowTree(rootNode); node;
-       node = nextTraversingShadowTree(*node, &rootNode)) {
+  for (ContainerNode* node = nextTraversingShadowTree(rootNode, &rootNode);
+       node; node = nextTraversingShadowTree(*node, &rootNode)) {
     if (!node->isElementNode())
       continue;
     Element* element = toElement(node);
     if (selectorListMatches<SelectorQueryTrait>(rootNode, *element, output) &&
         SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
 static const CSSSelector* selectorForIdLookup(
@@ skipping 146 matching lines @@
   return m_entries
       .insert(selectors, SelectorQuery::adopt(std::move(selectorList)))
       .storedValue->value.get();
 }
 
 void SelectorQueryCache::invalidate() {
   m_entries.clear();
 }
 
 }  // namespace blink