blink: Rename enums and functions to not collide with chromium style.

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 249 matching lines @@
         if (toShadowRoot(element.parentNode())->type() != ShadowRootType::V0)
             return nullptr;
     }
     return element.parentOrShadowHostElement();
 }
 
 SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingContext& context, MatchResult& result) const
 {
     SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
-    CSSSelector::Relation relation = context.selector->relation();
+    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;
 
     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;
         }
 
-        if (nextContext.selector->pseudoType() == CSSSelector::PseudoShadow)
+        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);
             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);
 
-            if (nextContext.selector->pseudoType() == CSSSelector::PseudoShadow)
+            if (nextContext.selector->getPseudoType() == CSSSelector::PseudoShadow)
                 return matchForPseudoShadow(nextContext, context.element->parentNode(), result);
 
             nextContext.element = parentElement(context);
             if (!nextContext.element)
                 return SelectorFailsCompletely;
             return matchSelector(nextContext, result);
         }
     case CSSSelector::DirectAdjacent:
         // Shadow roots can't have sibling elements
-        if (nextContext.selector->pseudoType() == CSSSelector::PseudoShadow)
+        if (nextContext.selector->getPseudoType() == CSSSelector::PseudoShadow)
             return SelectorFailsCompletely;
 
         if (m_mode == ResolvingStyle) {
             if (ContainerNode* parent = context.element->parentElementOrShadowRoot())
                 parent->setChildrenAffectedByDirectAdjacentRules();
         }
         nextContext.element = ElementTraversal::previousSibling(*context.element);
         if (!nextContext.element)
             return SelectorFailsAllSiblings;
         return matchSelector(nextContext, result);
 
     case CSSSelector::IndirectAdjacent:
         // Shadow roots can't have sibling elements
-        if (nextContext.selector->pseudoType() == CSSSelector::PseudoShadow)
+        if (nextContext.selector->getPseudoType() == CSSSelector::PseudoShadow)
             return SelectorFailsCompletely;
 
         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);
             if (match == SelectorMatches || match == SelectorFailsAllSiblings || match == SelectorFailsCompletely)
                 return match;
         }
         return SelectorFailsAllSiblings;
 
     case CSSSelector::ShadowPseudo:
         {
-            if (!m_isUARule && context.selector->pseudoType() == CSSSelector::PseudoShadow)
+            if (!m_isUARule && context.selector->getPseudoType() == CSSSelector::PseudoShadow)
                 Deprecation::countDeprecation(context.element->document(), UseCounter::CSSSelectorPseudoShadow);
             // 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())
                 return SelectorFailsCompletely;
 
             Element* shadowHost = context.element->shadowHost();
             if (!shadowHost)
                 return SelectorFailsCompletely;
             nextContext.element = shadowHost;
             return matchSelector(nextContext, result);
@@ skipping 71 matching lines @@
     return false;
 }
 
 static inline bool containsHTMLSpace(const AtomicString& string)
 {
     if (LIKELY(string.is8Bit()))
         return containsHTMLSpaceTemplate<LChar>(string.characters8(), string.length());
     return containsHTMLSpaceTemplate<UChar>(string.characters16(), string.length());
 }
 
-static bool attributeValueMatches(const Attribute& attributeItem, CSSSelector::Match match, const AtomicString& selectorValue, TextCaseSensitivity caseSensitivity)
+static bool attributeValueMatches(const Attribute& attributeItem, CSSSelector::MatchType match, const AtomicString& selectorValue, TextCaseSensitivity caseSensitivity)
 {
     // TODO(esprehn): How do we get here with a null value?
     const AtomicString& value = attributeItem.value();
     if (value.isNull())
         return false;
 
     switch (match) {
     case CSSSelector::AttributeExact:
         if (caseSensitivity == TextCaseSensitive)
             return selectorValue == value;
@@ skipping 44 matching lines @@
             return false;
         return true;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return true;
 }
 
-static bool anyAttributeMatches(Element& element, CSSSelector::Match match, const CSSSelector& selector)
+static bool anyAttributeMatches(Element& element, CSSSelector::MatchType match, const CSSSelector& selector)
 {
     const QualifiedName& selectorAttr = selector.attribute();
     ASSERT(selectorAttr.localName() != starAtom); // Should not be possible from the CSS grammar.
 
     // Synchronize the attribute in case it is lazy-computed.
     // Currently all lazy properties have a null namespace, so only pass localName().
     element.synchronizeAttribute(selectorAttr.localName());
 
     const AtomicString& selectorValue = selector.value();
-    TextCaseSensitivity caseSensitivity = (selector.attributeMatchType() == CSSSelector::CaseInsensitive) ? TextCaseASCIIInsensitive : TextCaseSensitive;
+    TextCaseSensitivity caseSensitivity = (selector.attributeMatch() == CSSSelector::CaseInsensitive) ? TextCaseASCIIInsensitive : TextCaseSensitive;
 
     AttributeCollection attributes = element.attributesWithoutUpdate();
     for (const auto& attributeItem: attributes) {
         if (!attributeItem.matches(selectorAttr))
             continue;
 
         if (attributeValueMatches(attributeItem, match, selectorValue, caseSensitivity))
             return true;
 
         if (caseSensitivity == TextCaseASCIIInsensitive) {
@@ skipping 71 matching lines @@
 {
     const CSSSelector& selector = *context.selector;
 
     SelectorCheckingContext subContext(context);
     subContext.isSubSelector = true;
     ASSERT(selector.selectorList());
     for (subContext.selector = selector.selectorList()->first(); subContext.selector; subContext.selector = subContext.selector->tagHistory()) {
         // :not cannot nest. I don't really know why this is a
         // restriction in CSS3, but it is, so let's honor it.
         // the parser enforces that this never occurs
-        ASSERT(subContext.selector->pseudoType() != CSSSelector::PseudoNot);
+        ASSERT(subContext.selector->getPseudoType() != CSSSelector::PseudoNot);
         // We select between :visited and :link when applying. We don't know which one applied (or not) yet.
-        if (subContext.selector->pseudoType() == CSSSelector::PseudoVisited || (subContext.selector->pseudoType() == CSSSelector::PseudoLink && subContext.visitedMatchType == VisitedMatchEnabled))
+        if (subContext.selector->getPseudoType() == CSSSelector::PseudoVisited || (subContext.selector->getPseudoType() == CSSSelector::PseudoLink && subContext.visitedMatchType == VisitedMatchEnabled))
             return true;
         // context.scope is not available if m_mode == SharingRules.
         // We cannot determine whether :host or :scope matches a given element or not.
-        if (m_mode == SharingRules && (subContext.selector->isHostPseudoClass() || subContext.selector->pseudoType() == CSSSelector::PseudoScope))
+        if (m_mode == SharingRules && (subContext.selector->isHostPseudoClass() || subContext.selector->getPseudoType() == CSSSelector::PseudoScope))
             return true;
         if (!checkOne(subContext, result))
             return true;
     }
     return false;
 }
 
 bool SelectorChecker::checkPseudoClass(const SelectorCheckingContext& context, MatchResult& result) const
 {
     Element& element = *context.element;
     const CSSSelector& selector = *context.selector;
 
     if (context.hasScrollbarPseudo) {
         // CSS scrollbars match a specific subset of pseudo classes, and they have specialized rules for each
         // (since there are no elements involved).
         return checkScrollbarPseudoClass(context, result);
     }
 
-    switch (selector.pseudoType()) {
+    switch (selector.getPseudoType()) {
     case CSSSelector::PseudoNot:
         return checkPseudoNot(context, result);
     case CSSSelector::PseudoEmpty:
         {
             bool result = true;
             for (Node* n = element.firstChild(); n; n = n->nextSibling()) {
                 if (n->isElementNode()) {
                     result = false;
                     break;
                 }
@@ skipping 303 matching lines @@
         break;
     }
     return false;
 }
 
 bool SelectorChecker::checkPseudoElement(const SelectorCheckingContext& context, MatchResult& result) const
 {
     const CSSSelector& selector = *context.selector;
     Element& element = *context.element;
 
-    switch (selector.pseudoType()) {
+    switch (selector.getPseudoType()) {
     case CSSSelector::PseudoCue:
         {
             SelectorCheckingContext subContext(context);
             subContext.isSubSelector = true;
             subContext.scope = nullptr;
             subContext.treatShadowHostAsNormalScope = false;
 
             for (subContext.selector = selector.selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(*subContext.selector)) {
                 if (match(subContext))
                     return true;
@@ skipping 20 matching lines @@
             return match(subContext);
         }
     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.pseudoType());
+        result.dynamicPseudo = CSSSelector::pseudoId(selector.getPseudoType());
         ASSERT(result.dynamicPseudo != NOPSEUDO);
         return true;
     }
 }
 
 bool SelectorChecker::checkPseudoHost(const SelectorCheckingContext& context, MatchResult& result) const
 {
     const CSSSelector& selector = *context.selector;
     Element& element = *context.element;
 
@@ skipping 29 matching lines @@
             hostContext.element = nextElement;
             if (match(hostContext, subResult)) {
                 matched = true;
                 // Consider div:host(div:host(div:host(div:host...))).
                 maxSpecificity = std::max(maxSpecificity, hostContext.selector->specificity() + subResult.specificity);
                 break;
             }
             hostContext.treatShadowHostAsNormalScope = false;
             hostContext.scope = nullptr;
 
-            if (selector.pseudoType() == CSSSelector::PseudoHost)
+            if (selector.getPseudoType() == CSSSelector::PseudoHost)
                 break;
 
             hostContext.inRightmostCompound = false;
             nextElement = FlatTreeTraversal::parentElement(*nextElement);
         } while (nextElement);
     }
     if (matched) {
         result.specificity += maxSpecificity;
         return true;
     }
 
     // FIXME: this was a fallthrough condition.
     return false;
 }
 
 bool SelectorChecker::checkScrollbarPseudoClass(const SelectorCheckingContext& context, MatchResult& result) const
 {
     const CSSSelector& selector = *context.selector;
 
-    if (selector.pseudoType() == CSSSelector::PseudoNot)
+    if (selector.getPseudoType() == CSSSelector::PseudoNot)
         return checkPseudoNot(context, result);
 
     // FIXME: This is a temporary hack for resizers and scrollbar corners. Eventually :window-inactive should become a real
     // pseudo class and just apply to everything.
-    if (selector.pseudoType() == CSSSelector::PseudoWindowInactive)
+    if (selector.getPseudoType() == CSSSelector::PseudoWindowInactive)
         return !context.element->document().page()->focusController().isActive();
 
     if (!m_scrollbar)
         return false;
 
-    switch (selector.pseudoType()) {
+    switch (selector.getPseudoType()) {
     case CSSSelector::PseudoEnabled:
         return m_scrollbar->enabled();
     case CSSSelector::PseudoDisabled:
         return !m_scrollbar->enabled();
     case CSSSelector::PseudoHover:
         {
             ScrollbarPart hoveredPart = m_scrollbar->hoveredPart();
             if (m_scrollbarPart == ScrollbarBGPart)
                 return hoveredPart != NoPart;
             if (m_scrollbarPart == TrackBGPart)
@@ skipping 54 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