Rename enums/functions that collide in chromium style in core/dom/

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 149 matching lines @@
         for (Node* node : liveNodeSet()) {
             if (node->hasRareData()) {
                 ++nodesWithRareData;
                 if (node->isElementNode()) {
                     ++elementsWithRareData;
                     if (toElement(node)->hasNamedNodeMap())
                         ++elementsWithNamedNodeMap;
                 }
             }
 
-            switch (node->nodeType()) {
+            switch (node->getNodeType()) {
             case ELEMENT_NODE: {
                 ++elementNodes;
 
                 // Tag stats
                 Element* element = toElement(node);
                 HashMap<String, size_t>::AddResult result = perTagCount.add(element->tagName(), 1);
                 if (!result.isNewEntry)
                     result.storedValue->value++;
 
                 if (const ElementData* elementData = element->elementData()) {
@@ skipping 331 matching lines @@
     // Go through the subtree beneath us, normalizing all nodes. This means that
     // any two adjacent text nodes are merged and any empty text nodes are removed.
 
     RefPtrWillBeRawPtr<Node> node = this;
     while (Node* firstChild = node->firstChild())
         node = firstChild;
     while (node) {
         if (node == this)
             break;
 
-        if (node->nodeType() == TEXT_NODE)
+        if (node->getNodeType() == TEXT_NODE)
             node = toText(node)->mergeNextSiblingNodesIfPossible();
         else
             node = NodeTraversal::nextPostOrder(*node);
     }
 }
 
 bool Node::isContentEditable(UserSelectAllTreatment treatment) const
 {
     document().updateLayoutTreeIfNeeded();
     return hasEditableStyle(Editable, treatment);
@@ skipping 188 matching lines @@
     if (!inActiveDocument())
         return;
 
     TRACE_EVENT_INSTANT1(
         TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
         "StyleRecalcInvalidationTracking",
         TRACE_EVENT_SCOPE_THREAD,
         "data",
         InspectorStyleRecalcInvalidationTrackingEvent::data(this, reason));
 
-    StyleChangeType existingChangeType = styleChangeType();
+    StyleChangeType existingChangeType = getStyleChangeType();
     if (changeType > existingChangeType)
         setStyleChange(changeType);
 
     if (existingChangeType == NoStyleChange)
         markAncestorsWithChildNeedsStyleRecalc();
 
     if (isElementNode() && hasRareData())
         toElement(*this).setAnimationStyleChange(false);
 }
 
@@ skipping 150 matching lines @@
     ASSERT(!otherIterator);
     return nullptr;
 }
 
 void Node::reattach(const AttachContext& context)
 {
     AttachContext reattachContext(context);
     reattachContext.performingReattach = true;
 
     // We only need to detach if the node has already been through attach().
-    if (styleChangeType() < NeedsReattachStyleChange)
+    if (getStyleChangeType() < NeedsReattachStyleChange)
         detach(reattachContext);
     attach(reattachContext);
 }
 
 void Node::attach(const AttachContext&)
 {
     ASSERT(document().inStyleRecalc() || isDocumentNode());
     ASSERT(!document().lifecycle().inDetach());
     ASSERT(needsAttach());
     ASSERT(!layoutObject() || (layoutObject()->style() && (layoutObject()->parent() || layoutObject()->isLayoutView())));
@@ skipping 197 matching lines @@
 const KURL& Node::baseURI() const
 {
     return document().baseURL();
 }
 
 bool Node::isEqualNode(Node* other) const
 {
     if (!other)
         return false;
 
-    NodeType nodeType = this->nodeType();
-    if (nodeType != other->nodeType())
+    NodeType nodeType = this->getNodeType();
+    if (nodeType != other->getNodeType())
         return false;
 
     if (nodeName() != other->nodeName())
         return false;
 
     if (nodeValue() != other->nodeValue())
         return false;
 
     if (isAttributeNode()) {
         if (toAttr(this)->localName() != toAttr(other)->localName())
@@ skipping 37 matching lines @@
             return false;
     }
 
     return true;
 }
 
 bool Node::isDefaultNamespace(const AtomicString& namespaceURIMaybeEmpty) const
 {
     const AtomicString& namespaceURI = namespaceURIMaybeEmpty.isEmpty() ? nullAtom : namespaceURIMaybeEmpty;
 
-    switch (nodeType()) {
+    switch (getNodeType()) {
     case ELEMENT_NODE: {
         const Element& element = toElement(*this);
 
         if (element.prefix().isNull())
             return element.namespaceURI() == namespaceURI;
 
         AttributeCollection attributes = element.attributes();
         for (const Attribute& attr : attributes) {
             if (attr.localName() == xmlnsAtom)
                 return attr.value() == namespaceURI;
@@ skipping 27 matching lines @@
 const AtomicString& Node::lookupPrefix(const AtomicString& namespaceURI) const
 {
     // Implemented according to
     // https://dom.spec.whatwg.org/#dom-node-lookupprefix
 
     if (namespaceURI.isEmpty() || namespaceURI.isNull())
         return nullAtom;
 
     const Element* context;
 
-    switch (nodeType()) {
+    switch (getNodeType()) {
     case ELEMENT_NODE:
         context = toElement(this);
         break;
     case DOCUMENT_NODE:
         context = toDocument(this)->documentElement();
         break;
     case DOCUMENT_FRAGMENT_NODE:
     case DOCUMENT_TYPE_NODE:
         context = nullptr;
         break;
@@ skipping 13 matching lines @@
 }
 
 const AtomicString& Node::lookupNamespaceURI(const String& prefix) const
 {
     // Implemented according to
     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
 
     if (!prefix.isNull() && prefix.isEmpty())
         return nullAtom;
 
-    switch (nodeType()) {
+    switch (getNodeType()) {
     case ELEMENT_NODE: {
         const Element& element = toElement(*this);
 
         if (!element.namespaceURI().isNull() && element.prefix() == prefix)
             return element.namespaceURI();
 
         AttributeCollection attributes = element.attributes();
         for (const Attribute& attr : attributes) {
             if (attr.prefix() == xmlnsAtom && attr.localName() == prefix) {
                 if (!attr.value().isEmpty())
@@ skipping 50 matching lines @@
             content.append('\n');
         } else if (node.isTextNode()) {
             content.append(toText(node).data());
         }
     }
     return content.toString();
 }
 
 void Node::setTextContent(const String& text)
 {
-    switch (nodeType()) {
+    switch (getNodeType()) {
     case TEXT_NODE:
     case CDATA_SECTION_NODE:
     case COMMENT_NODE:
     case PROCESSING_INSTRUCTION_NODE:
         setNodeValue(text);
         return;
     case ELEMENT_NODE:
     case DOCUMENT_FRAGMENT_NODE: {
         // FIXME: Merge this logic into replaceChildrenWithText.
         RefPtrWillBeRawPtr<ContainerNode> container = toContainerNode(this);
@@ skipping 27 matching lines @@
 bool Node::offsetInCharacters() const
 {
     return isCharacterDataNode();
 }
 
 unsigned short Node::compareDocumentPosition(const Node* otherNode, ShadowTreesTreatment treatment) const
 {
     if (otherNode == this)
         return DOCUMENT_POSITION_EQUIVALENT;
 
-    const Attr* attr1 = nodeType() == ATTRIBUTE_NODE ? toAttr(this) : nullptr;
-    const Attr* attr2 = otherNode->nodeType() == ATTRIBUTE_NODE ? toAttr(otherNode) : nullptr;
+    const Attr* attr1 = getNodeType() == ATTRIBUTE_NODE ? toAttr(this) : nullptr;
+    const Attr* attr2 = otherNode->getNodeType() == ATTRIBUTE_NODE ? toAttr(otherNode) : nullptr;
 
     const Node* start1 = attr1 ? attr1->ownerElement() : this;
     const Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
 
     // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
     // an orphaned attribute node.
     if (!start1 || !start2) {
         unsigned short direction = (this > otherNode) ? DOCUMENT_POSITION_PRECEDING : DOCUMENT_POSITION_FOLLOWING;
         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
     }
@@ skipping 50 matching lines @@
     }
 
     unsigned connection = start1->treeScope() != start2->treeScope() ? DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC : 0;
 
     // Walk the two chains backwards and look for the first difference.
     for (unsigned i = std::min(index1, index2); i; --i) {
         const Node* child1 = chain1[--index1];
         const Node* child2 = chain2[--index2];
         if (child1 != child2) {
             // If one of the children is an attribute, it wins.
-            if (child1->nodeType() == ATTRIBUTE_NODE)
+            if (child1->getNodeType() == ATTRIBUTE_NODE)
                 return DOCUMENT_POSITION_FOLLOWING | connection;
-            if (child2->nodeType() == ATTRIBUTE_NODE)
+            if (child2->getNodeType() == ATTRIBUTE_NODE)
                 return DOCUMENT_POSITION_PRECEDING | connection;
 
             // If one of the children is a shadow root,
             if (child1->isShadowRoot() || child2->isShadowRoot()) {
                 if (!child2->isShadowRoot())
                     return Node::DOCUMENT_POSITION_FOLLOWING | connection;
                 if (!child1->isShadowRoot())
                     return Node::DOCUMENT_POSITION_PRECEDING | connection;
 
                 for (const ShadowRoot* child = toShadowRoot(child2)->olderShadowRoot(); child; child = child->olderShadowRoot()) {
@@ skipping 77 matching lines @@
 {
     if (!prefix)
         prefix = "";
     if (isTextNode()) {
         String value = nodeValue();
         value.replaceWithLiteral('\\', "\\\\");
         value.replaceWithLiteral('\n', "\\n");
         WTFLogAlways("%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
     } else if (isDocumentTypeNode()) {
         WTFLogAlways("%sDOCTYPE %s\t%p\n", prefix, nodeName().utf8().data(), this);
-    } else if (nodeType() == PROCESSING_INSTRUCTION_NODE) {
+    } else if (getNodeType() == PROCESSING_INSTRUCTION_NODE) {
         WTFLogAlways("%s?%s\t%p\n", prefix, nodeName().utf8().data(), this);
     } else if (isShadowRoot()) {
         // nodeName of ShadowRoot is #document-fragment.  It's confused with
         // DocumentFragment.
         WTFLogAlways("%s#shadow-root\t%p\n", prefix, this);
     } else {
         StringBuilder attrs;
         appendAttributeDesc(this, attrs, idAttr, " ID");
         appendAttributeDesc(this, attrs, classAttr, " CLASS");
         appendAttributeDesc(this, attrs, styleAttr, " STYLE");
@@ skipping 26 matching lines @@
     for (unsigned index = chain.size(); index > 0; --index) {
         const Node* node = chain[index - 1];
         if (node->isShadowRoot()) {
             int count = 0;
             for (const ShadowRoot* shadowRoot = toShadowRoot(node)->olderShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot())
                 ++count;
             WTFLogAlways("/#shadow-root[%d]", count);
             continue;
         }
 
-        switch (node->nodeType()) {
+        switch (node->getNodeType()) {
         case ELEMENT_NODE: {
             WTFLogAlways("/%s", node->nodeName().utf8().data());
 
             const Element* element = toElement(node);
             const AtomicString& idattr = element->getIdAttribute();
             bool hasIdAttr = !idattr.isNull() && !idattr.isEmpty();
             if (node->previousSibling() || node->nextSibling()) {
                 int count = 0;
                 for (const Node* previous = node->previousSibling(); previous; previous = previous->previousSibling()) {
                     if (previous->nodeName() == node->nodeName()) {
@@ skipping 760 matching lines @@
         visitor->trace(rareData());
 
     visitor->trace(m_treeScope);
 #endif
     EventTarget::trace(visitor);
 }
 
 unsigned Node::lengthOfContents() const
 {
     // This switch statement must be consistent with that of Range::processContentsBetweenOffsets.
-    switch (nodeType()) {
+    switch (getNodeType()) {
     case Node::TEXT_NODE:
     case Node::CDATA_SECTION_NODE:
     case Node::COMMENT_NODE:
     case Node::PROCESSING_INSTRUCTION_NODE:
         return toCharacterData(this)->length();
     case Node::ELEMENT_NODE:
     case Node::DOCUMENT_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
         return toContainerNode(this)->countChildren();
     case Node::ATTRIBUTE_NODE:
@@ skipping 50 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif