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

third_party/WebKit/Source/core/css/RuleFeature.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 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 31 matching lines @@
 #include "core/dom/Node.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "wtf/BitVector.h"
 
 namespace blink {
 
 namespace {
 
 #if ENABLE(ASSERT)
 
-bool supportsInvalidation(CSSSelector::Match match)
+bool supportsInvalidation(CSSSelector::MatchType match)
 {
     switch (match) {
     case CSSSelector::Tag:
     case CSSSelector::Id:
     case CSSSelector::Class:
     case CSSSelector::AttributeExact:
     case CSSSelector::AttributeSet:
     case CSSSelector::AttributeHyphen:
     case CSSSelector::AttributeList:
     case CSSSelector::AttributeContain:
@@ skipping 117 matching lines @@
 
 #endif // ENABLE(ASSERT)
 
 bool requiresSubtreeInvalidation(const CSSSelector& selector)
 {
     if (selector.match() != CSSSelector::PseudoElement && selector.match() != CSSSelector::PseudoClass) {
         ASSERT(supportsInvalidation(selector.match()));
         return false;
     }
 
-    switch (selector.pseudoType()) {
+    switch (selector.getPseudoType()) {
     case CSSSelector::PseudoFirstLine:
     case CSSSelector::PseudoFirstLetter:
         // FIXME: Most pseudo classes/elements above can be supported and moved
         // to assertSupportedPseudo(). Move on a case-by-case basis. If they
         // require subtree invalidation, document why.
     case CSSSelector::PseudoHostContext:
         // :host-context matches a shadow host, yet the simple selectors inside
         // :host-context matches an ancestor of the shadow host.
         return true;
     default:
-        ASSERT(supportsInvalidation(selector.pseudoType()));
+        ASSERT(supportsInvalidation(selector.getPseudoType()));
         return false;
     }
 }
 
 template<class Map>
 InvalidationSet& ensureInvalidationSet(Map& map, const typename Map::KeyType& key, InvalidationType type)
 {
     typename Map::AddResult addResult = map.add(key, nullptr);
     if (addResult.isNewEntry) {
         if (type == InvalidateDescendants)
@@ skipping 77 matching lines @@
         return true;
     }
     if (selector.match() == CSSSelector::Class) {
         features.classes.append(selector.value());
         return true;
     }
     if (selector.isAttributeSelector()) {
         features.attributes.append(selector.attribute().localName());
         return true;
     }
-    if (selector.pseudoType() == CSSSelector::PseudoWebKitCustomElement) {
+    if (selector.getPseudoType() == CSSSelector::PseudoWebKitCustomElement) {
         features.customPseudoElement = true;
         return true;
     }
-    if (selector.pseudoType() == CSSSelector::PseudoBefore || selector.pseudoType() == CSSSelector::PseudoAfter)
+    if (selector.getPseudoType() == CSSSelector::PseudoBefore || selector.getPseudoType() == CSSSelector::PseudoAfter)
         features.hasBeforeOrAfter = true;
     return false;
 }
 
 InvalidationSet* RuleFeatureSet::invalidationSetForSelector(const CSSSelector& selector, InvalidationType type)
 {
     if (selector.match() == CSSSelector::Class)
         return &ensureClassInvalidationSet(selector.value(), type);
     if (selector.isAttributeSelector())
         return &ensureAttributeInvalidationSet(selector.attribute().localName(), type);
     if (selector.match() == CSSSelector::Id)
         return &ensureIdInvalidationSet(selector.value(), type);
     if (selector.match() == CSSSelector::PseudoClass) {
-        switch (selector.pseudoType()) {
+        switch (selector.getPseudoType()) {
         case CSSSelector::PseudoEmpty:
         case CSSSelector::PseudoLink:
         case CSSSelector::PseudoVisited:
         case CSSSelector::PseudoAnyLink:
         case CSSSelector::PseudoAutofill:
         case CSSSelector::PseudoHover:
         case CSSSelector::PseudoDrag:
         case CSSSelector::PseudoFocus:
         case CSSSelector::PseudoActive:
         case CSSSelector::PseudoChecked:
         case CSSSelector::PseudoEnabled:
         // TODO(rune@opera.com): crbug.com/557683 :default is currently not updated dynamically.
         // case CSSSelector::Default:
         case CSSSelector::PseudoDisabled:
         case CSSSelector::PseudoOptional:
         case CSSSelector::PseudoPlaceholderShown:
         case CSSSelector::PseudoRequired:
         case CSSSelector::PseudoReadOnly:
         case CSSSelector::PseudoReadWrite:
         case CSSSelector::PseudoValid:
         case CSSSelector::PseudoInvalid:
         case CSSSelector::PseudoIndeterminate:
         case CSSSelector::PseudoTarget:
         case CSSSelector::PseudoLang:
         case CSSSelector::PseudoInRange:
         case CSSSelector::PseudoOutOfRange:
         case CSSSelector::PseudoUnresolved:
-            return &ensurePseudoInvalidationSet(selector.pseudoType(), type);
+            return &ensurePseudoInvalidationSet(selector.getPseudoType(), type);
         default:
             break;
         }
     }
     return nullptr;
 }
 
 // Given a rule, update the descendant invalidation sets for the features found
 // in its selector. The first step is to extract the features from the rightmost
 // compound selector (extractInvalidationSetFeatures). Secondly, add those features
@@ skipping 57 matching lines @@
         } else {
             if (requiresSubtreeInvalidation(*current)) {
                 // Fall back to use subtree invalidations, even for features in the
                 // rightmost compound selector. Returning the start &selector here
                 // will make addFeaturesToInvalidationSets start marking invalidation
                 // sets for subtree recalc for features in the rightmost compound
                 // selector.
                 return std::make_pair(&selector, ForceSubtree);
             }
             if (const CSSSelectorList* selectorList = current->selectorList()) {
-                if (current->pseudoType() == CSSSelector::PseudoSlotted) {
+                if (current->getPseudoType() == CSSSelector::PseudoSlotted) {
                     ASSERT(position == Subject);
                     features.invalidatesSlotted = true;
                 }
-                ASSERT(supportsInvalidationWithSelectorList(current->pseudoType()));
+                ASSERT(supportsInvalidationWithSelectorList(current->getPseudoType()));
                 const CSSSelector* subSelector = selectorList->first();
                 bool allSubSelectorsHaveFeatures = !!subSelector;
                 for (; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
-                    auto result = extractInvalidationSetFeatures(*subSelector, features, position, current->pseudoType());
+                    auto result = extractInvalidationSetFeatures(*subSelector, features, position, current->getPseudoType());
                     if (result.first) {
                         // A non-null selector return means the sub-selector contained a
                         // selector which requiresSubtreeInvalidation(). Return the rightmost
                         // selector to mark for subtree recalcs like above.
                         return std::make_pair(&selector, ForceSubtree);
                     }
                     allSubSelectorsHaveFeatures &= result.second == UseFeatures;
                 }
                 foundFeatures |= allSubSelectorsHaveFeatures;
             }
@@ skipping 73 matching lines @@
                     addFeaturesToInvalidationSet(siblingInvalidationSet->ensureSiblingDescendants(), descendantFeatures);
             } else {
                 addFeaturesToInvalidationSet(*invalidationSet, descendantFeatures);
             }
         } else {
             if (current->isHostPseudoClass())
                 descendantFeatures.treeBoundaryCrossing = true;
             if (current->isInsertionPointCrossing())
                 descendantFeatures.insertionPointCrossing = true;
             if (const CSSSelectorList* selectorList = current->selectorList()) {
-                ASSERT(supportsInvalidationWithSelectorList(current->pseudoType()));
+                ASSERT(supportsInvalidationWithSelectorList(current->getPseudoType()));
                 for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(*subSelector))
                     addFeaturesToInvalidationSets(subSelector, siblingFeatures, descendantFeatures);
             }
         }
 
         if (current->relation() == CSSSelector::SubSelector)
             continue;
 
         if (current->relationIsAffectedByPseudoContent() || current->relation() == CSSSelector::ShadowSlot) {
             descendantFeatures.insertionPointCrossing = true;
@@ skipping 39 matching lines @@
     if (ruleData.containsUncommonAttributeSelector())
         uncommonAttributeRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
 
     updateInvalidationSets(ruleData);
     return SelectorMayMatch;
 }
 
 RuleFeatureSet::SelectorPreMatch RuleFeatureSet::collectFeaturesFromSelector(const CSSSelector& selector, RuleFeatureSet::FeatureMetadata& metadata)
 {
     unsigned maxDirectAdjacentSelectors = 0;
-    CSSSelector::Relation relation = CSSSelector::Descendant;
+    CSSSelector::RelationType relation = CSSSelector::Descendant;
     bool foundHostPseudo = false;
 
     for (const CSSSelector* current = &selector; current; current = current->tagHistory()) {
-        switch (current->pseudoType()) {
+        switch (current->getPseudoType()) {
         case CSSSelector::PseudoFirstLine:
             metadata.usesFirstLineRules = true;
             break;
         case CSSSelector::PseudoWindowInactive:
             metadata.usesWindowInactiveSelector = true;
             break;
         case CSSSelector::PseudoEmpty:
         case CSSSelector::PseudoFirstChild:
         case CSSSelector::PseudoFirstOfType:
         case CSSSelector::PseudoLastChild:
@@ skipping 16 matching lines @@
             foundHostPseudo = true;
             // fall through.
         default:
             if (const CSSSelectorList* selectorList = current->selectorList()) {
                 for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(*subSelector))
                     collectFeaturesFromSelector(*subSelector, metadata);
             }
             break;
         }
 
-        if (current->relationIsAffectedByPseudoContent() || current->pseudoType() == CSSSelector::PseudoSlotted)
+        if (current->relationIsAffectedByPseudoContent() || current->getPseudoType() == CSSSelector::PseudoSlotted)
             metadata.foundInsertionPointCrossing = true;
 
         relation = current->relation();
 
         if (foundHostPseudo && relation != CSSSelector::SubSelector)
             return SelectorNeverMatches;
 
         if (relation == CSSSelector::DirectAdjacent) {
             maxDirectAdjacentSelectors++;
         } else if (maxDirectAdjacentSelectors
@@ skipping 141 matching lines @@
 
 DEFINE_TRACE(RuleFeatureSet)
 {
 #if ENABLE(OILPAN)
     visitor->trace(siblingRules);
     visitor->trace(uncommonAttributeRules);
 #endif
 }
 
 } // namespace blink