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

third_party/WebKit/Source/core/css/CSSSelector.cpp

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
  *               2001-2003 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2002, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 82 matching lines @@
 
 inline unsigned CSSSelector::specificityForOneSelector() const
 {
     // FIXME: Pseudo-elements and pseudo-classes do not have the same specificity. This function
     // isn't quite correct.
     // http://www.w3.org/TR/selectors/#specificity
     switch (m_match) {
     case Id:
         return 0x010000;
     case PseudoClass:
-        switch (pseudoType()) {
+        switch (getPseudoType()) {
         case PseudoHost:
         case PseudoHostContext:
             // We dynamically compute the specificity of :host and :host-context
             // during matching.
             return 0;
         case PseudoNot:
             ASSERT(selectorList());
             return selectorList()->first()->specificityForOneSelector();
         // FIXME: PseudoAny should base the specificity on the sub-selectors.
         // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0530.html
@@ skipping 27 matching lines @@
 {
     // See http://dev.w3.org/csswg/css3-page/#cascading-and-page-context
     unsigned s = 0;
 
     for (const CSSSelector* component = this; component; component = component->tagHistory()) {
         switch (component->m_match) {
         case Tag:
             s += tagQName().localName() == starAtom ? 0 : 4;
             break;
         case PagePseudoClass:
-            switch (component->pseudoType()) {
+            switch (component->getPseudoType()) {
             case PseudoFirstPage:
                 s += 2;
                 break;
             case PseudoLeftPage:
             case PseudoRightPage:
                 s += 1;
                 break;
             default:
                 ASSERT_NOT_REACHED();
             }
@@ skipping 247 matching lines @@
     return static_cast<CSSSelector::PseudoType>(match->type);
 }
 
 #ifndef NDEBUG
 void CSSSelector::show(int indent) const
 {
     printf("%*sselectorText(): %s\n", indent, "", selectorText().ascii().data());
     printf("%*sm_match: %d\n", indent, "", m_match);
     if (m_match != Tag)
         printf("%*svalue(): %s\n", indent, "", value().ascii().data());
-    printf("%*spseudoType(): %d\n", indent, "", pseudoType());
+    printf("%*sgetPseudoType(): %d\n", indent, "", getPseudoType());
     if (m_match == Tag)
         printf("%*stagQName().localName: %s\n", indent, "", tagQName().localName().ascii().data());
     printf("%*sisAttributeSelector(): %d\n", indent, "", isAttributeSelector());
     if (isAttributeSelector())
         printf("%*sattribute(): %s\n", indent, "", attribute().localName().ascii().data());
     printf("%*sargument(): %s\n", indent, "", argument().ascii().data());
     printf("%*sspecificity(): %u\n", indent, "", specificity());
     if (tagHistory()) {
         printf("\n%*s--> (relation == %d)\n", indent, "", relation());
         tagHistory()->show(indent + 2);
@@ skipping 132 matching lines @@
 bool CSSSelector::operator==(const CSSSelector& other) const
 {
     const CSSSelector* sel1 = this;
     const CSSSelector* sel2 = &other;
 
     while (sel1 && sel2) {
         if (sel1->attribute() != sel2->attribute()
             || sel1->relation() != sel2->relation()
             || sel1->m_match != sel2->m_match
             || sel1->value() != sel2->value()
-            || sel1->pseudoType() != sel2->pseudoType()
+            || sel1->getPseudoType() != sel2->getPseudoType()
             || sel1->argument() != sel2->argument()) {
             return false;
         }
         if (sel1->m_match == Tag) {
             if (sel1->tagQName() != sel2->tagQName())
                 return false;
         }
         sel1 = sel1->tagHistory();
         sel2 = sel2->tagHistory();
     }
@@ skipping 23 matching lines @@
         if (cs->m_match == Id) {
             str.append('#');
             serializeIdentifier(cs->serializingValue(), str);
         } else if (cs->m_match == Class) {
             str.append('.');
             serializeIdentifier(cs->serializingValue(), str);
         } else if (cs->m_match == PseudoClass || cs->m_match == PagePseudoClass) {
             str.append(':');
             str.append(cs->serializingValue());
 
-            switch (cs->pseudoType()) {
+            switch (cs->getPseudoType()) {
             case PseudoNthChild:
             case PseudoNthLastChild:
             case PseudoNthOfType:
             case PseudoNthLastOfType: {
                 str.append('(');
 
                 // http://dev.w3.org/csswg/css-syntax/#serializing-anb
                 int a = cs->m_data.m_rareData->nthAValue();
                 int b = cs->m_data.m_rareData->nthBValue();
                 if (a == 0 && b == 0)
@@ skipping 57 matching lines @@
                 str.appendLiteral("$=");
                 break;
             case AttributeContain:
                 str.appendLiteral("*=");
                 break;
             default:
                 break;
             }
             if (cs->m_match != AttributeSet) {
                 serializeString(cs->serializingValue(), str);
-                if (cs->attributeMatchType() == CaseInsensitive)
+                if (cs->attributeMatch() == CaseInsensitive)
                     str.appendLiteral(" i");
                 str.append(']');
             }
         }
 
         if (cs->selectorList()) {
             str.append('(');
             const CSSSelector* firstSubSelector = cs->selectorList()->first();
             for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
                 if (subSelector != firstSubSelector)
@@ skipping 27 matching lines @@
             return tagHistory->selectorText(str.toString() + rightSide);
         }
     }
     return str.toString() + rightSide;
 }
 
 void CSSSelector::setAttribute(const QualifiedName& value, AttributeMatchType matchType)
 {
     createRareData();
     m_data.m_rareData->m_attribute = value;
-    m_data.m_rareData->m_bits.m_attributeMatchType = matchType;
+    m_data.m_rareData->m_bits.m_attributeMatch = matchType;
 }
 
 void CSSSelector::setArgument(const AtomicString& value)
 {
     createRareData();
     m_data.m_rareData->m_argument = value;
 }
 
 void CSSSelector::setSelectorList(PassOwnPtr<CSSSelectorList> selectorList)
 {
@@ skipping 16 matching lines @@
     case CSSSelector::AttributeEnd:
         return true;
     case CSSSelector::PseudoElement:
     case CSSSelector::Unknown:
         return false;
     case CSSSelector::PagePseudoClass:
     case CSSSelector::PseudoClass:
         break;
     }
 
-    switch (selector->pseudoType()) {
+    switch (selector->getPseudoType()) {
     case CSSSelector::PseudoEmpty:
     case CSSSelector::PseudoLink:
     case CSSSelector::PseudoVisited:
     case CSSSelector::PseudoTarget:
     case CSSSelector::PseudoEnabled:
     case CSSSelector::PseudoDisabled:
     case CSSSelector::PseudoChecked:
     case CSSSelector::PseudoIndeterminate:
     case CSSSelector::PseudoNthChild:
     case CSSSelector::PseudoNthLastChild:
@@ skipping 36 matching lines @@
     return true;
 }
 
 unsigned CSSSelector::computeLinkMatchType() const
 {
     unsigned linkMatchType = MatchAll;
 
     // Determine if this selector will match a link in visited, unvisited or any state, or never.
     // :visited never matches other elements than the innermost link element.
     for (const CSSSelector* current = this; current; current = current->tagHistory()) {
-        switch (current->pseudoType()) {
+        switch (current->getPseudoType()) {
         case PseudoNot:
             {
                 // :not(:visited) is equivalent to :link. Parser enforces that :not can't nest.
                 ASSERT(current->selectorList());
                 for (const CSSSelector* subSelector = current->selectorList()->first(); subSelector; subSelector = subSelector->tagHistory()) {
-                    PseudoType subType = subSelector->pseudoType();
+                    PseudoType subType = subSelector->getPseudoType();
                     if (subType == PseudoVisited)
                         linkMatchType &= ~MatchVisited;
                     else if (subType == PseudoLink)
                         linkMatchType &= ~MatchLink;
                 }
             }
             break;
         case PseudoLink:
             linkMatchType &= ~MatchVisited;
             break;
         case PseudoVisited:
             linkMatchType &= ~MatchLink;
             break;
         default:
             // We don't support :link and :visited inside :-webkit-any.
             break;
         }
-        Relation relation = current->relation();
+        RelationType relation = current->relation();
         if (relation == SubSelector)
             continue;
         if (relation != Descendant && relation != Child)
             return linkMatchType;
         if (linkMatchType != MatchAll)
             return linkMatchType;
     }
     return linkMatchType;
 }
 
@@ skipping 43 matching lines @@
         if (count < nthBValue())
             return false;
         return (count - nthBValue()) % nthAValue() == 0;
     }
     if (count > nthBValue())
         return false;
     return (nthBValue() - count) % (-nthAValue()) == 0;
 }
 
 } // namespace blink