Allow positional selectors to match elements without a parent.

third_party/WebKit/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/)
@@ skipping 745 matching lines @@
         if (context.inRightmostCompound)
           m_elementStyle->setEmptyState(result);
         else if (element.computedStyle() &&
                  (element.document().styleEngine().usesSiblingRules() ||
                   element.computedStyle()->unique()))
           element.mutableComputedStyle()->setEmptyState(result);
       }
       return result;
     }
     case CSSSelector::PseudoFirstChild:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle) {
+      if (m_mode == ResolvingStyle) {
+        if (ContainerNode* parent = element.parentElementOrDocumentFragment())
           parent->setChildrenAffectedByFirstChildRules();
-          element.setAffectedByFirstChildRules();
-        }
-        return isFirstChild(element);
+        element.setAffectedByFirstChildRules();
       }
-      break;
+      return isFirstChild(element);
     case CSSSelector::PseudoFirstOfType:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle)
+      if (m_mode == ResolvingStyle) {
+        if (ContainerNode* parent = element.parentElementOrDocumentFragment())
           parent->setChildrenAffectedByForwardPositionalRules();
-        return isFirstOfType(element, element.tagQName());
       }
-      break;
-    case CSSSelector::PseudoLastChild:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle) {
+      return isFirstOfType(element, element.tagQName());
+    case CSSSelector::PseudoLastChild: {
+      ContainerNode* parent = element.parentElementOrDocumentFragment();
+      if (m_mode == ResolvingStyle) {
+        if (parent)
           parent->setChildrenAffectedByLastChildRules();
-          element.setAffectedByLastChildRules();
-        }
-        if (!m_isQuerySelector && !parent->isFinishedParsingChildren())
-          return false;
-        return isLastChild(element);
+        element.setAffectedByLastChildRules();
       }
-      break;
-    case CSSSelector::PseudoLastOfType:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle)
+      if (!m_isQuerySelector && parent && !parent->isFinishedParsingChildren())
+        return false;
+      return isLastChild(element);
+    }
+    case CSSSelector::PseudoLastOfType: {
+      ContainerNode* parent = element.parentElementOrDocumentFragment();
+      if (m_mode == ResolvingStyle) {
+        if (parent)
           parent->setChildrenAffectedByBackwardPositionalRules();
-        if (!m_isQuerySelector && !parent->isFinishedParsingChildren())
-          return false;
-        return isLastOfType(element, element.tagQName());
       }
-      break;
-    case CSSSelector::PseudoOnlyChild:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle) {
+      if (!m_isQuerySelector && parent && !parent->isFinishedParsingChildren())
+        return false;
+      return isLastOfType(element, element.tagQName());
+    }
+    case CSSSelector::PseudoOnlyChild: {
+      ContainerNode* parent = element.parentElementOrDocumentFragment();
+      if (m_mode == ResolvingStyle) {
+        if (parent) {
           parent->setChildrenAffectedByFirstChildRules();
           parent->setChildrenAffectedByLastChildRules();
-          element.setAffectedByFirstChildRules();
-          element.setAffectedByLastChildRules();
         }
-        if (!m_isQuerySelector && !parent->isFinishedParsingChildren())
-          return false;
-        return isFirstChild(element) && isLastChild(element);
+        element.setAffectedByFirstChildRules();
+        element.setAffectedByLastChildRules();
       }
-      break;
-    case CSSSelector::PseudoOnlyOfType:
+      if (!m_isQuerySelector && parent && !parent->isFinishedParsingChildren())
+        return false;
+      return isFirstChild(element) && isLastChild(element);
+    }
+    case CSSSelector::PseudoOnlyOfType: {
       // FIXME: This selector is very slow.
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle) {
-          parent->setChildrenAffectedByForwardPositionalRules();
-          parent->setChildrenAffectedByBackwardPositionalRules();
-        }
-        if (!m_isQuerySelector && !parent->isFinishedParsingChildren())
-          return false;
-        return isFirstOfType(element, element.tagQName()) &&
-               isLastOfType(element, element.tagQName());
+      ContainerNode* parent = element.parentElementOrDocumentFragment();
+      if (m_mode == ResolvingStyle && parent) {
+        parent->setChildrenAffectedByForwardPositionalRules();
+        parent->setChildrenAffectedByBackwardPositionalRules();
       }
-      break;
+      if (!m_isQuerySelector && parent && !parent->isFinishedParsingChildren())
+        return false;
+      return isFirstOfType(element, element.tagQName()) &&
+             isLastOfType(element, element.tagQName());
+    }
     case CSSSelector::PseudoPlaceholderShown:
       if (isTextControlElement(element))
         return toTextControlElement(element).isPlaceholderVisible();
       break;
     case CSSSelector::PseudoNthChild:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle)
+      if (m_mode == ResolvingStyle) {
+        if (ContainerNode* parent = element.parentElementOrDocumentFragment())
           parent->setChildrenAffectedByForwardPositionalRules();
-        return selector.matchNth(NthIndexCache::nthChildIndex(element));
       }
-      break;
+      return selector.matchNth(NthIndexCache::nthChildIndex(element));
     case CSSSelector::PseudoNthOfType:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle)
+      if (m_mode == ResolvingStyle) {
+        if (ContainerNode* parent = element.parentElementOrDocumentFragment())
           parent->setChildrenAffectedByForwardPositionalRules();
-        return selector.matchNth(NthIndexCache::nthOfTypeIndex(element));
       }
-      break;
-    case CSSSelector::PseudoNthLastChild:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle)
-          parent->setChildrenAffectedByBackwardPositionalRules();
-        if (!m_isQuerySelector && !parent->isFinishedParsingChildren())
-          return false;
-        return selector.matchNth(NthIndexCache::nthLastChildIndex(element));
-      }
-      break;
-    case CSSSelector::PseudoNthLastOfType:
-      if (ContainerNode* parent = element.parentElementOrDocumentFragment()) {
-        if (m_mode == ResolvingStyle)
-          parent->setChildrenAffectedByBackwardPositionalRules();
-        if (!m_isQuerySelector && !parent->isFinishedParsingChildren())
-          return false;
-        return selector.matchNth(NthIndexCache::nthLastOfTypeIndex(element));
-      }
-      break;
+      return selector.matchNth(NthIndexCache::nthOfTypeIndex(element));
+    case CSSSelector::PseudoNthLastChild: {
+      ContainerNode* parent = element.parentElementOrDocumentFragment();
+      if (m_mode == ResolvingStyle && parent)
+        parent->setChildrenAffectedByBackwardPositionalRules();
+      if (!m_isQuerySelector && parent && !parent->isFinishedParsingChildren())
+        return false;
+      return selector.matchNth(NthIndexCache::nthLastChildIndex(element));
+    }
+    case CSSSelector::PseudoNthLastOfType: {
+      ContainerNode* parent = element.parentElementOrDocumentFragment();
+      if (m_mode == ResolvingStyle && parent)
+        parent->setChildrenAffectedByBackwardPositionalRules();
+      if (!m_isQuerySelector && parent && !parent->isFinishedParsingChildren())
+        return false;
+      return selector.matchNth(NthIndexCache::nthLastOfTypeIndex(element));
+    }
     case CSSSelector::PseudoTarget:
       return element == element.document().cssTarget();
     case CSSSelector::PseudoAny: {
       SelectorCheckingContext subContext(context);
       subContext.isSubSelector = true;
       DCHECK(selector.selectorList());
       for (subContext.selector = selector.selectorList()->first();
            subContext.selector;
            subContext.selector = CSSSelectorList::next(*subContext.selector)) {
         if (match(subContext))
@@ skipping 440 matching lines @@
 }
 
 bool SelectorChecker::matchesFocusPseudoClass(const Element& element) {
   if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(&element),
                                                  CSSSelector::PseudoFocus))
     return true;
   return element.isFocused() && isFrameFocused(element);
 }
 
 }  // namespace blink