Rename Blink constants generated from IDL files.

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 139 matching lines @@
             if (node->hasRareData()) {
                 ++nodesWithRareData;
                 if (node->isElementNode()) {
                     ++elementsWithRareData;
                     if (toElement(node)->hasNamedNodeMap())
                         ++elementsWithNamedNodeMap;
                 }
             }
 
             switch (node->getNodeType()) {
-            case ELEMENT_NODE: {
+            case kElementNode: {
                 ++elementNodes;
 
                 // Tag stats
                 Element* element = toElement(node);
                 HashMap<String, size_t>::AddResult result = perTagCount.add(element->tagName(), 1);
                 if (!result.isNewEntry)
                     result.storedValue->value++;
 
                 size_t attributeCount = element->attributesWithoutUpdate().size();
                 if (attributeCount) {
                     attributes += attributeCount;
                     ++elementsWithAttributeStorage;
                 }
                 break;
             }
-            case ATTRIBUTE_NODE: {
+            case kAttributeNode: {
                 ++attrNodes;
                 break;
             }
-            case TEXT_NODE: {
+            case kTextNode: {
                 ++textNodes;
                 break;
             }
-            case CDATA_SECTION_NODE: {
+            case kCdataSectionNode: {
                 ++cdataNodes;
                 break;
             }
-            case COMMENT_NODE: {
+            case kCommentNode: {
                 ++commentNodes;
                 break;
             }
-            case PROCESSING_INSTRUCTION_NODE: {
+            case kProcessingInstructionNode: {
                 ++piNodes;
                 break;
             }
-            case DOCUMENT_NODE: {
+            case kDocumentNode: {
                 ++documentNodes;
                 break;
             }
-            case DOCUMENT_TYPE_NODE: {
+            case kDocumentTypeNode: {
                 ++docTypeNodes;
                 break;
             }
-            case DOCUMENT_FRAGMENT_NODE: {
+            case kDocumentFragmentNode: {
                 if (node->isShadowRoot())
                     ++shadowRootNodes;
                 else
                     ++fragmentNodes;
                 break;
             }
             }
         }
     }
 
@@ skipping 312 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.
 
     Node* node = this;
     while (Node* firstChild = node->firstChild())
         node = firstChild;
     while (node) {
         if (node == this)
             break;
 
-        if (node->getNodeType() == TEXT_NODE)
+        if (node->getNodeType() == kTextNode)
             node = toText(node)->mergeNextSiblingNodesIfPossible();
         else
             node = NodeTraversal::nextPostOrder(*node);
     }
 }
 
 LayoutBox* Node::layoutBox() const
 {
     LayoutObject* layoutObject = this->layoutObject();
     return layoutObject && layoutObject->isBox() ? toLayoutBox(layoutObject) : nullptr;
@@ skipping 575 matching lines @@
     }
 
     return true;
 }
 
 bool Node::isDefaultNamespace(const AtomicString& namespaceURIMaybeEmpty) const
 {
     const AtomicString& namespaceURI = namespaceURIMaybeEmpty.isEmpty() ? nullAtom : namespaceURIMaybeEmpty;
 
     switch (getNodeType()) {
-    case ELEMENT_NODE: {
+    case kElementNode: {
         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;
         }
 
         if (Element* parent = parentElement())
             return parent->isDefaultNamespace(namespaceURI);
 
         return false;
     }
-    case DOCUMENT_NODE:
+    case kDocumentNode:
         if (Element* de = toDocument(this)->documentElement())
             return de->isDefaultNamespace(namespaceURI);
         return false;
-    case DOCUMENT_TYPE_NODE:
-    case DOCUMENT_FRAGMENT_NODE:
+    case kDocumentTypeNode:
+    case kDocumentFragmentNode:
         return false;
-    case ATTRIBUTE_NODE: {
+    case kAttributeNode: {
         const Attr* attr = toAttr(this);
         if (attr->ownerElement())
             return attr->ownerElement()->isDefaultNamespace(namespaceURI);
         return false;
     }
     default:
         if (Element* parent = parentElement())
             return parent->isDefaultNamespace(namespaceURI);
         return false;
     }
 }
 
 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 (getNodeType()) {
-    case ELEMENT_NODE:
+    case kElementNode:
         context = toElement(this);
         break;
-    case DOCUMENT_NODE:
+    case kDocumentNode:
         context = toDocument(this)->documentElement();
         break;
-    case DOCUMENT_FRAGMENT_NODE:
-    case DOCUMENT_TYPE_NODE:
+    case kDocumentFragmentNode:
+    case kDocumentTypeNode:
         context = nullptr;
         break;
     // FIXME: Remove this when Attr no longer extends Node (CR305105)
-    case ATTRIBUTE_NODE:
+    case kAttributeNode:
         context = toAttr(this)->ownerElement();
         break;
     default:
         context = parentElement();
         break;
     }
 
     if (!context)
         return nullAtom;
 
     return context->locateNamespacePrefix(namespaceURI);
 }
 
 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 (getNodeType()) {
-    case ELEMENT_NODE: {
+    case kElementNode: {
         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())
                     return attr.value();
                 return nullAtom;
             }
             if (attr.localName() == xmlnsAtom && prefix.isNull()) {
                 if (!attr.value().isEmpty())
                     return attr.value();
                 return nullAtom;
             }
         }
 
         if (Element* parent = parentElement())
             return parent->lookupNamespaceURI(prefix);
         return nullAtom;
     }
-    case DOCUMENT_NODE:
+    case kDocumentNode:
         if (Element* de = toDocument(this)->documentElement())
             return de->lookupNamespaceURI(prefix);
         return nullAtom;
-    case DOCUMENT_TYPE_NODE:
-    case DOCUMENT_FRAGMENT_NODE:
+    case kDocumentTypeNode:
+    case kDocumentFragmentNode:
         return nullAtom;
-    case ATTRIBUTE_NODE: {
+    case kAttributeNode: {
         const Attr *attr = toAttr(this);
         if (attr->ownerElement())
             return attr->ownerElement()->lookupNamespaceURI(prefix);
         return nullAtom;
     }
     default:
         if (Element* parent = parentElement())
             return parent->lookupNamespaceURI(prefix);
         return nullAtom;
     }
@@ skipping 19 matching lines @@
         } else if (node.isTextNode()) {
             content.append(toText(node).data());
         }
     }
     return content.toString();
 }
 
 void Node::setTextContent(const String& text)
 {
     switch (getNodeType()) {
-    case TEXT_NODE:
-    case CDATA_SECTION_NODE:
-    case COMMENT_NODE:
-    case PROCESSING_INSTRUCTION_NODE:
+    case kTextNode:
+    case kCdataSectionNode:
+    case kCommentNode:
+    case kProcessingInstructionNode:
         setNodeValue(text);
         return;
-    case ELEMENT_NODE:
-    case DOCUMENT_FRAGMENT_NODE: {
+    case kElementNode:
+    case kDocumentFragmentNode: {
         // FIXME: Merge this logic into replaceChildrenWithText.
         ContainerNode* container = toContainerNode(this);
 
         // Note: This is an intentional optimization.
         // See crbug.com/352836 also.
         // No need to do anything if the text is identical.
         if (container->hasOneTextChild() && toText(container->firstChild())->data() == text)
             return;
 
         ChildListMutationScope mutation(*this);
         // Note: This API will not insert empty text nodes:
         // https://dom.spec.whatwg.org/#dom-node-textcontent
         if (text.isEmpty()) {
             container->removeChildren(DispatchSubtreeModifiedEvent);
         } else {
             container->removeChildren(OmitSubtreeModifiedEvent);
             container->appendChild(document().createTextNode(text), ASSERT_NO_EXCEPTION);
         }
         return;
     }
-    case ATTRIBUTE_NODE:
-    case DOCUMENT_NODE:
-    case DOCUMENT_TYPE_NODE:
+    case kAttributeNode:
+    case kDocumentNode:
+    case kDocumentTypeNode:
         // Do nothing.
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 bool Node::offsetInCharacters() const
 {
     return isCharacterDataNode();
 }
 
 unsigned short Node::compareDocumentPosition(const Node* otherNode, ShadowTreesTreatment treatment) const
 {
     if (otherNode == this)
-        return DOCUMENT_POSITION_EQUIVALENT;
+        return kDocumentPositionEquivalent;
 
-    const Attr* attr1 = getNodeType() == ATTRIBUTE_NODE ? toAttr(this) : nullptr;
-    const Attr* attr2 = otherNode->getNodeType() == ATTRIBUTE_NODE ? toAttr(otherNode) : nullptr;
+    const Attr* attr1 = getNodeType() == kAttributeNode ? toAttr(this) : nullptr;
+    const Attr* attr2 = otherNode->getNodeType() == kAttributeNode ? 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;
+        unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding : kDocumentPositionFollowing;
+        return kDocumentPositionDisconnected | kDocumentPositionImplementationSpecific | direction;
     }
 
     HeapVector<Member<const Node>, 16> chain1;
     HeapVector<Member<const Node>, 16> chain2;
     if (attr1)
         chain1.append(attr1);
     if (attr2)
         chain2.append(attr2);
 
     if (attr1 && attr2 && start1 == start2 && start1) {
         // We are comparing two attributes on the same node. Crawl our attribute map and see which one we hit first.
         const Element* owner1 = attr1->ownerElement();
         AttributeCollection attributes = owner1->attributes();
         for (const Attribute& attr : attributes) {
             // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an
             // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
             // the same nodeType are inserted into or removed from the direct container. This would be the case, for example,
             // when comparing two attributes of the same element, and inserting or removing additional attributes might change
             // the order between existing attributes.
             if (attr1->getQualifiedName() == attr.name())
-                return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
+                return kDocumentPositionImplementationSpecific | kDocumentPositionFollowing;
             if (attr2->getQualifiedName() == attr.name())
-                return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
+                return kDocumentPositionImplementationSpecific | kDocumentPositionPreceding;
         }
 
         ASSERT_NOT_REACHED();
-        return DOCUMENT_POSITION_DISCONNECTED;
+        return kDocumentPositionDisconnected;
     }
 
     // If one node is in the document and the other is not, we must be disconnected.
     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
     // comparing Attr nodes here, since they return false from isConnected() all the time (which seems like a bug).
     if (start1->isConnected() != start2->isConnected() || (treatment == TreatShadowTreesAsDisconnected && start1->treeScope() != start2->treeScope())) {
-        unsigned short direction = (this > otherNode) ? DOCUMENT_POSITION_PRECEDING : DOCUMENT_POSITION_FOLLOWING;
-        return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
+        unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding : kDocumentPositionFollowing;
+        return kDocumentPositionDisconnected | kDocumentPositionImplementationSpecific | direction;
     }
 
     // We need to find a common ancestor container, and then compare the indices of the two immediate children.
     const Node* current;
     for (current = start1; current; current = current->parentOrShadowHostNode())
         chain1.append(current);
     for (current = start2; current; current = current->parentOrShadowHostNode())
         chain2.append(current);
 
     unsigned index1 = chain1.size();
     unsigned index2 = chain2.size();
 
     // If the two elements don't have a common root, they're not in the same tree.
     if (chain1[index1 - 1] != chain2[index2 - 1]) {
-        unsigned short direction = (this > otherNode) ? DOCUMENT_POSITION_PRECEDING : DOCUMENT_POSITION_FOLLOWING;
-        return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
+        unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding : kDocumentPositionFollowing;
+        return kDocumentPositionDisconnected | kDocumentPositionImplementationSpecific | direction;
     }
 
-    unsigned connection = start1->treeScope() != start2->treeScope() ? DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC : 0;
+    unsigned connection = start1->treeScope() != start2->treeScope() ? kDocumentPositionDisconnected | kDocumentPositionImplementationSpecific : 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->getNodeType() == ATTRIBUTE_NODE)
-                return DOCUMENT_POSITION_FOLLOWING | connection;
-            if (child2->getNodeType() == ATTRIBUTE_NODE)
-                return DOCUMENT_POSITION_PRECEDING | connection;
+            if (child1->getNodeType() == kAttributeNode)
+                return kDocumentPositionFollowing | connection;
+            if (child2->getNodeType() == kAttributeNode)
+                return kDocumentPositionPreceding | connection;
 
             // If one of the children is a shadow root,
             if (child1->isShadowRoot() || child2->isShadowRoot()) {
                 if (!child2->isShadowRoot())
-                    return Node::DOCUMENT_POSITION_FOLLOWING | connection;
+                    return Node::kDocumentPositionFollowing | connection;
                 if (!child1->isShadowRoot())
-                    return Node::DOCUMENT_POSITION_PRECEDING | connection;
+                    return Node::kDocumentPositionPreceding | connection;
 
                 for (const ShadowRoot* child = toShadowRoot(child2)->olderShadowRoot(); child; child = child->olderShadowRoot()) {
                     if (child == child1) {
-                        return Node::DOCUMENT_POSITION_FOLLOWING | connection;
+                        return Node::kDocumentPositionFollowing | connection;
                     }
                 }
 
-                return Node::DOCUMENT_POSITION_PRECEDING | connection;
+                return Node::kDocumentPositionPreceding | connection;
             }
 
             if (!child2->nextSibling())
-                return DOCUMENT_POSITION_FOLLOWING | connection;
+                return kDocumentPositionFollowing | connection;
             if (!child1->nextSibling())
-                return DOCUMENT_POSITION_PRECEDING | connection;
+                return kDocumentPositionPreceding | connection;
 
             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
             for (const Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
                 if (child == child1)
-                    return DOCUMENT_POSITION_FOLLOWING | connection;
+                    return kDocumentPositionFollowing | connection;
             }
-            return DOCUMENT_POSITION_PRECEDING | connection;
+            return kDocumentPositionPreceding | connection;
         }
     }
 
     // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
     // chain is the ancestor.
     return index1 < index2 ?
-        DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY | connection :
-        DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS | connection;
+        kDocumentPositionFollowing | kDocumentPositionContainedBy | connection :
+        kDocumentPositionPreceding | kDocumentPositionContains | connection;
 }
 
 String Node::debugName() const
 {
     StringBuilder name;
     name.append(debugNodeName());
     if (isElementNode()) {
         const Element& thisElement = toElement(*this);
         if (thisElement.hasID()) {
             name.append(" id=\'");
@@ skipping 70 matching lines @@
 {
     if (!prefix)
         prefix = "";
     if (isTextNode()) {
         String value = nodeValue();
         value.replace('\\', "\\\\");
         value.replace('\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 (getNodeType() == PROCESSING_INSTRUCTION_NODE) {
+    } else if (getNodeType() == kProcessingInstructionNode) {
         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 27 matching lines @@
         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->getNodeType()) {
-        case ELEMENT_NODE: {
+        case kElementNode: {
             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()) {
                         ++count;
                     }
                 }
                 if (hasIdAttr)
                     WTFLogAlways("[@id=\"%s\" and position()=%d]", idattr.utf8().data(), count);
                 else
                     WTFLogAlways("[%d]", count);
             } else if (hasIdAttr) {
                 WTFLogAlways("[@id=\"%s\"]", idattr.utf8().data());
             }
             break;
         }
-        case TEXT_NODE:
+        case kTextNode:
             WTFLogAlways("/text()");
             break;
-        case ATTRIBUTE_NODE:
+        case kAttributeNode:
             WTFLogAlways("/@%s", node->nodeName().utf8().data());
             break;
         default:
             break;
         }
     }
     WTFLogAlways("\n");
 }
 
 static void traverseTreeAndMark(const String& baseIndent, const Node* rootNode, const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2)
@@ skipping 720 matching lines @@
     visitor->traceWrappers(m_next);
     if (hasRareData())
         visitor->traceWrappers(rareData());
     EventTarget::traceWrappers(visitor);
 }
 
 unsigned Node::lengthOfContents() const
 {
     // This switch statement must be consistent with that of Range::processContentsBetweenOffsets.
     switch (getNodeType()) {
-    case Node::TEXT_NODE:
-    case Node::CDATA_SECTION_NODE:
-    case Node::COMMENT_NODE:
-    case Node::PROCESSING_INSTRUCTION_NODE:
+    case Node::kTextNode:
+    case Node::kCdataSectionNode:
+    case Node::kCommentNode:
+    case Node::kProcessingInstructionNode:
         return toCharacterData(this)->length();
-    case Node::ELEMENT_NODE:
-    case Node::DOCUMENT_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
+    case Node::kElementNode:
+    case Node::kDocumentNode:
+    case Node::kDocumentFragmentNode:
         return toContainerNode(this)->countChildren();
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_TYPE_NODE:
+    case Node::kAttributeNode:
+    case Node::kDocumentTypeNode:
         return 0;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 v8::Local<v8::Object> Node::wrap(v8::Isolate* isolate, v8::Local<v8::Object> creationContext)
 {
     DCHECK(!DOMDataStore::containsWrapper(this, isolate));
 
@@ skipping 34 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif