style: Rename the PseudoId enum values to CamelCase and prefix them.

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/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 174 matching lines @@
 // * 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(const SelectorCheckingContext& context, MatchResult& result) const
 {
     MatchResult subResult;
     if (!checkOne(context, subResult))
         return SelectorFailsLocally;
 
-    if (subResult.dynamicPseudo != NOPSEUDO)
+    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;
     if (context.selector->relation() != CSSSelector::SubSelector) {
         if (nextSelectorExceedsScope(context))
             return SelectorFailsCompletely;
 
-        if (context.pseudoId != NOPSEUDO && context.pseudoId != result.dynamicPseudo)
+        if (context.pseudoId != PseudoIdNone && context.pseudoId != result.dynamicPseudo)
             return SelectorFailsCompletely;
 
-        TemporaryChange<PseudoId> dynamicPseudoScope(result.dynamicPseudo, NOPSEUDO);
+        TemporaryChange<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);
     ASSERT(context.selector->tagHistory());
     nextContext.selector = context.selector->tagHistory();
     return nextContext;
 }
 
 SelectorChecker::Match SelectorChecker::matchForSubSelector(const SelectorCheckingContext& context, MatchResult& result) const
 {
     SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
     PseudoId dynamicPseudo = result.dynamicPseudo;
-    nextContext.hasScrollbarPseudo = dynamicPseudo != NOPSEUDO && (m_scrollbar || dynamicPseudo == SCROLLBAR_CORNER || dynamicPseudo == RESIZER);
-    nextContext.hasSelectionPseudo = dynamicPseudo == SELECTION;
+    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(const SelectorCheckingContext& context, const ContainerNode* node, MatchResult& result) const
@@ skipping 20 matching lines @@
 
     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() || (relation != CSSSelector::Descendant && relation != CSSSelector::Child)))
         nextContext.visitedMatchType = VisitedMatchDisabled;
 
     nextContext.inRightmostCompound = false;
     nextContext.isSubSelector = false;
     nextContext.previousElement = context.element;
-    nextContext.pseudoId = NOPSEUDO;
+    nextContext.pseudoId = PseudoIdNone;
 
     switch (relation) {
     case CSSSelector::Descendant:
         if (context.selector->relationIsAffectedByPseudoContent()) {
             for (Element* element = context.element; element; element = element->parentElement()) {
                 if (matchForPseudoContent(nextContext, *element, result) == SelectorMatches)
                     return SelectorMatches;
             }
             return SelectorFailsCompletely;
         }
@@ skipping 698 matching lines @@
         }
     case CSSSelector::PseudoContent:
         return element.isInShadowTree() && element.isInsertionPoint();
     case CSSSelector::PseudoShadow:
         return element.isInShadowTree() && context.previousElement;
     default:
         if (m_mode == SharingRules)
             return true;
         ASSERT(m_mode != QueryingRules);
         result.dynamicPseudo = CSSSelector::pseudoId(selector.getPseudoType());
-        ASSERT(result.dynamicPseudo != NOPSEUDO);
+        ASSERT(result.dynamicPseudo != PseudoIdNone);
         return true;
     }
 }
 
 bool SelectorChecker::checkPseudoHost(const SelectorCheckingContext& context, MatchResult& result) const
 {
     const CSSSelector& selector = *context.selector;
     Element& element = *context.element;
 
     if (m_mode == SharingRules)
@@ skipping 134 matching lines @@
 }
 
 bool SelectorChecker::matchesFocusPseudoClass(const Element& element)
 {
     if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(&element), CSSSelector::PseudoFocus))
         return true;
     return element.focused() && isFrameFocused(element);
 }
 
 } // namespace blink