Rename blink::SelectorChecker::Match enum type to MatchStatus.

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 182 matching lines @@
   return !ElementTraversal::nextSibling(element, HasTagName(type));
 }
 
 // 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
-SelectorChecker::Match SelectorChecker::matchSelector(
+SelectorChecker::MatchStatus SelectorChecker::matchSelector(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   MatchResult subResult;
   if (!checkOne(context, subResult))
     return SelectorFailsLocally;
 
   if (subResult.dynamicPseudo != PseudoIdNone)
     result.dynamicPseudo = subResult.dynamicPseudo;
 
   if (context.selector->isLastInTagHistory()) {
     if (scopeContainsLastMatchedElement(context)) {
       result.specificity += subResult.specificity;
       return SelectorMatches;
     }
     return SelectorFailsLocally;
   }
 
-  Match match;
+  MatchStatus match;
   if (context.selector->relation() != CSSSelector::SubSelector) {
     if (nextSelectorExceedsScope(context))
       return SelectorFailsCompletely;
 
     if (context.pseudoId != PseudoIdNone &&
         context.pseudoId != result.dynamicPseudo)
       return SelectorFailsCompletely;
 
     AutoReset<PseudoId> dynamicPseudoScope(&result.dynamicPseudo, PseudoIdNone);
     match = matchForRelation(context, result);
   } else {
     match = matchForSubSelector(context, result);
   }
   if (match == SelectorMatches)
     result.specificity += subResult.specificity;
   return match;
 }
 
 static inline SelectorChecker::SelectorCheckingContext
 prepareNextContextForRelation(
     const SelectorChecker::SelectorCheckingContext& context) {
   SelectorChecker::SelectorCheckingContext nextContext(context);
   DCHECK(context.selector->tagHistory());
   nextContext.selector = context.selector->tagHistory();
   return nextContext;
 }
 
-SelectorChecker::Match SelectorChecker::matchForSubSelector(
+SelectorChecker::MatchStatus SelectorChecker::matchForSubSelector(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
   PseudoId dynamicPseudo = result.dynamicPseudo;
   nextContext.hasScrollbarPseudo =
       dynamicPseudo != PseudoIdNone &&
       (m_scrollbar || dynamicPseudo == PseudoIdScrollbarCorner ||
        dynamicPseudo == PseudoIdResizer);
   nextContext.hasSelectionPseudo = dynamicPseudo == PseudoIdSelection;
   nextContext.isSubSelector = true;
   return matchSelector(nextContext, result);
 }
 
 static inline bool isV0ShadowRoot(const Node* node) {
   return node && node->isShadowRoot() &&
          toShadowRoot(node)->type() == ShadowRootType::V0;
 }
 
-SelectorChecker::Match SelectorChecker::matchForPseudoShadow(
+SelectorChecker::MatchStatus SelectorChecker::matchForPseudoShadow(
     const SelectorCheckingContext& context,
     const ContainerNode* node,
     MatchResult& result) const {
   if (!isV0ShadowRoot(node))
     return SelectorFailsCompletely;
   if (!context.previousElement)
     return SelectorFailsCompletely;
   return matchSelector(context, result);
 }
 
 static inline Element* parentOrV0ShadowHostElement(const Element& element) {
   if (element.parentNode() && element.parentNode()->isShadowRoot()) {
     if (toShadowRoot(element.parentNode())->type() != ShadowRootType::V0)
       return nullptr;
   }
   return element.parentOrShadowHostElement();
 }
 
 static inline Element* parentOrOpenShadowHostElement(const Element& element) {
   if (element.parentNode() && element.parentNode()->isShadowRoot()) {
     if (toShadowRoot(element.parentNode())->type() != ShadowRootType::Open)
       return nullptr;
   }
   return element.parentOrShadowHostElement();
 }
 
-SelectorChecker::Match SelectorChecker::matchForRelation(
+SelectorChecker::MatchStatus SelectorChecker::matchForRelation(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
   CSSSelector::RelationType 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() ||
@@ skipping 16 matching lines @@
         }
         return SelectorFailsCompletely;
       }
 
       if (nextContext.selector->getPseudoType() == CSSSelector::PseudoShadow)
         return matchForPseudoShadow(
             nextContext, context.element->containingShadowRoot(), result);
 
       for (nextContext.element = parentElement(context); nextContext.element;
            nextContext.element = parentElement(nextContext)) {
-        Match match = matchSelector(nextContext, result);
+        MatchStatus match = matchSelector(nextContext, result);
         if (match == SelectorMatches || match == SelectorFailsCompletely)
           return match;
         if (nextSelectorExceedsScope(nextContext))
           return SelectorFailsCompletely;
       }
       return SelectorFailsCompletely;
     case CSSSelector::Child: {
       if (context.selector->relationIsAffectedByPseudoContent())
         return matchForPseudoContent(nextContext, *context.element, result);
 
@@ skipping 28 matching lines @@
 
       if (m_mode == ResolvingStyle) {
         if (ContainerNode* parent =
                 context.element->parentElementOrShadowRoot())
           parent->setChildrenAffectedByIndirectAdjacentRules();
       }
       nextContext.element = ElementTraversal::previousSibling(*context.element);
       for (; nextContext.element;
            nextContext.element =
                ElementTraversal::previousSibling(*nextContext.element)) {
-        Match match = matchSelector(nextContext, result);
+        MatchStatus match = matchSelector(nextContext, result);
         if (match == SelectorMatches || match == SelectorFailsAllSiblings ||
             match == SelectorFailsCompletely)
           return match;
       }
       return SelectorFailsAllSiblings;
 
     case CSSSelector::ShadowPseudo: {
       if (!m_isUARule && !m_isQuerySelector &&
           context.selector->getPseudoType() == CSSSelector::PseudoShadow)
         Deprecation::countDeprecation(context.element->document(),
@@ skipping 34 matching lines @@
             return SelectorMatches;
           }
         }
         return SelectorFailsCompletely;
       }
 
       for (nextContext.element = parentOrV0ShadowHostElement(*context.element);
            nextContext.element;
            nextContext.element =
                parentOrV0ShadowHostElement(*nextContext.element)) {
-        Match match = matchSelector(nextContext, result);
+        MatchStatus match = matchSelector(nextContext, result);
         if (match == SelectorMatches && context.element->isInShadowTree())
           UseCounter::count(context.element->document(),
                             UseCounter::CSSDeepCombinatorAndShadow);
         if (match == SelectorMatches || match == SelectorFailsCompletely)
           return match;
         if (nextSelectorExceedsScope(nextContext))
           return SelectorFailsCompletely;
       }
       return SelectorFailsCompletely;
     }
 
     case CSSSelector::ShadowPiercingDescendant: {
       DCHECK(m_isQuerySelector);
       UseCounter::count(context.element->document(),
                         UseCounter::CSSShadowPiercingDescendantCombinator);
       // TODO(kochi): parentOrOpenShadowHostElement() is necessary because
       // SelectorQuery can pass V0 shadow roots. All closed shadow roots are
       // already filtered out, thus once V0 is removed this logic can use
       // parentOrShadowHostElement() instead.
       for (nextContext.element =
                parentOrOpenShadowHostElement(*context.element);
            nextContext.element;
            nextContext.element =
                parentOrOpenShadowHostElement(*nextContext.element)) {
-        Match match = matchSelector(nextContext, result);
+        MatchStatus match = matchSelector(nextContext, result);
         if (match == SelectorMatches || match == SelectorFailsCompletely)
           return match;
         if (nextSelectorExceedsScope(nextContext))
           break;
       }
       return SelectorFailsCompletely;
     }
 
     case CSSSelector::ShadowSlot: {
       const HTMLSlotElement* slot = findSlotElementInScope(context);
       if (!slot)
         return SelectorFailsCompletely;
 
       nextContext.element = const_cast<HTMLSlotElement*>(slot);
       return matchSelector(nextContext, result);
     }
 
     case CSSSelector::SubSelector:
       break;
   }
   NOTREACHED();
   return SelectorFailsCompletely;
 }
 
-SelectorChecker::Match SelectorChecker::matchForPseudoContent(
+SelectorChecker::MatchStatus SelectorChecker::matchForPseudoContent(
     const SelectorCheckingContext& context,
     const Element& element,
     MatchResult& result) const {
   HeapVector<Member<InsertionPoint>, 8> insertionPoints;
   collectDestinationInsertionPoints(element, insertionPoints);
   SelectorCheckingContext nextContext(context);
   for (const auto& insertionPoint : insertionPoints) {
     nextContext.element = insertionPoint;
     // TODO(esprehn): Why does SharingRules have a special case?
     if (m_mode == SharingRules)
@@ skipping 815 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