Rename Blink constants generated from IDL files.

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 271 matching lines @@
     // compare to end, and point comes after
     if (compareBoundaryPoints(refNode, offset, m_end.container(), m_end.offset(), exceptionState) > 0 && !exceptionState.hadException())
         return 1;
 
     // point is in the middle of this range, or on the boundary points
     return 0;
 }
 
 short Range::compareBoundaryPoints(unsigned how, const Range* sourceRange, ExceptionState& exceptionState) const
 {
-    if (!(how == START_TO_START || how == START_TO_END || how == END_TO_END || how == END_TO_START)) {
+    if (!(how == kStartToStart || how == kStartToEnd || how == kEndToEnd || how == kEndToStart)) {
         exceptionState.throwDOMException(NotSupportedError, "The comparison method provided must be one of 'START_TO_START', 'START_TO_END', 'END_TO_END', or 'END_TO_START'.");
         return 0;
     }
 
     Node* thisCont = commonAncestorContainer();
     Node* sourceCont = sourceRange->commonAncestorContainer();
     if (thisCont->document() != sourceCont->document()) {
         exceptionState.throwDOMException(WrongDocumentError, "The source range is in a different document than this range.");
         return 0;
     }
 
     Node* thisTop = thisCont;
     Node* sourceTop = sourceCont;
     while (thisTop->parentNode())
         thisTop = thisTop->parentNode();
     while (sourceTop->parentNode())
         sourceTop = sourceTop->parentNode();
     if (thisTop != sourceTop) { // in different DocumentFragments
         exceptionState.throwDOMException(WrongDocumentError, "The source range is in a different document than this range.");
         return 0;
     }
 
     switch (how) {
-    case START_TO_START:
+    case kStartToStart:
         return compareBoundaryPoints(m_start, sourceRange->m_start, exceptionState);
-    case START_TO_END:
+    case kStartToEnd:
         return compareBoundaryPoints(m_end, sourceRange->m_start, exceptionState);
-    case END_TO_END:
+    case kEndToEnd:
         return compareBoundaryPoints(m_end, sourceRange->m_end, exceptionState);
-    case END_TO_START:
+    case kEndToStart:
         return compareBoundaryPoints(m_start, sourceRange->m_end, exceptionState);
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 short Range::compareBoundaryPoints(Node* containerA, int offsetA, Node* containerB, int offsetB, ExceptionState& exceptionState)
 {
     bool disconnected = false;
@@ skipping 248 matching lines @@
 
 Node* Range::processContentsBetweenOffsets(ActionType action, DocumentFragment* fragment,
     Node* container, unsigned startOffset, unsigned endOffset, ExceptionState& exceptionState)
 {
     DCHECK(container);
     DCHECK_LE(startOffset, endOffset);
 
     // This switch statement must be consistent with that of Node::lengthOfContents.
     Node* result = nullptr;
     switch (container->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:
         endOffset = std::min(endOffset, toCharacterData(container)->length());
         if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
             CharacterData* c = static_cast<CharacterData*>(container->cloneNode(true));
             deleteCharacterData(c, startOffset, endOffset, exceptionState);
             if (fragment) {
                 result = fragment;
                 result->appendChild(c, exceptionState);
             } else {
                 result = c;
             }
         }
         if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS)
             toCharacterData(container)->deleteData(startOffset, endOffset - startOffset, exceptionState);
         break;
-    case Node::ELEMENT_NODE:
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_NODE:
-    case Node::DOCUMENT_TYPE_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
+    case Node::kElementNode:
+    case Node::kAttributeNode:
+    case Node::kDocumentNode:
+    case Node::kDocumentTypeNode:
+    case Node::kDocumentFragmentNode:
         // FIXME: Should we assert that some nodes never appear here?
         if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
             if (fragment)
                 result = fragment;
             else
                 result = container->cloneNode(false);
         }
 
         Node* n = container->firstChild();
         HeapVector<Member<Node>> nodes;
@@ skipping 120 matching lines @@
     // In the case where the container is a text node, we check against the container's parent, because
     // text nodes get split up upon insertion.
     Node* checkAgainst;
     if (startIsText)
         checkAgainst = m_start.container()->parentNode();
     else
         checkAgainst = m_start.container();
 
     Node::NodeType newNodeType = newNode->getNodeType();
     int numNewChildren;
-    if (newNodeType == Node::DOCUMENT_FRAGMENT_NODE && !newNode->isShadowRoot()) {
+    if (newNodeType == Node::kDocumentFragmentNode && !newNode->isShadowRoot()) {
         // check each child node, not the DocumentFragment itself
         numNewChildren = 0;
         for (Node* c = toDocumentFragment(newNode)->firstChild(); c; c = c->nextSibling()) {
             if (!checkAgainst->childTypeAllowed(c->getNodeType())) {
                 exceptionState.throwDOMException(HierarchyRequestError, "The node to be inserted contains a '" + c->nodeName() + "' node, which may not be inserted here.");
                 return;
             }
             ++numNewChildren;
         }
     } else {
         numNewChildren = 1;
         if (!checkAgainst->childTypeAllowed(newNodeType)) {
             exceptionState.throwDOMException(HierarchyRequestError, "The node to be inserted is a '" + newNode->nodeName() + "' node, which may not be inserted here.");
             return;
         }
     }
 
     for (Node& node : NodeTraversal::inclusiveAncestorsOf(*m_start.container())) {
         if (node == newNode) {
             exceptionState.throwDOMException(HierarchyRequestError, "The node to be inserted contains the insertion point; it may not be inserted into itself.");
             return;
         }
     }
 
     // InvalidNodeTypeError: Raised if newNode is an Attr, Entity, Notation, ShadowRoot or Document node.
     switch (newNodeType) {
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_NODE:
+    case Node::kAttributeNode:
+    case Node::kDocumentNode:
         exceptionState.throwDOMException(InvalidNodeTypeError, "The node to be inserted is a '" + newNode->nodeName() + "' node, which may not be inserted here.");
         return;
     default:
         if (newNode->isShadowRoot()) {
             exceptionState.throwDOMException(InvalidNodeTypeError, "The node to be inserted is a shadow root, which may not be inserted here.");
             return;
         }
         break;
     }
 
@@ skipping 15 matching lines @@
             // Some types of events don't support EventQueueScope.  Given
             // circumstance may mutate the tree so newText->parentNode() may
             // become null.
             if (!newText->parentNode()) {
                 exceptionState.throwDOMException(HierarchyRequestError, "This operation would set range's end to parent with new offset, but there's no parent into which to continue.");
                 return;
             }
             m_end.setToBeforeChild(*newText);
         }
     } else {
-        Node* lastChild = (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) ? toDocumentFragment(newNode)->lastChild() : newNode;
+        Node* lastChild = (newNodeType == Node::kDocumentFragmentNode) ? toDocumentFragment(newNode)->lastChild() : newNode;
         if (lastChild && lastChild == m_start.childBefore()) {
             // The insertion will do nothing, but we need to extend the range to include
             // the inserted nodes.
-            Node* firstChild = (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) ? toDocumentFragment(newNode)->firstChild() : newNode;
+            Node* firstChild = (newNodeType == Node::kDocumentFragmentNode) ? toDocumentFragment(newNode)->firstChild() : newNode;
             DCHECK(firstChild);
             m_start.setToBeforeChild(*firstChild);
             return;
         }
 
         container = m_start.container();
         container->insertBefore(newNode, NodeTraversal::childAt(*container, m_start.offset()), exceptionState);
         if (exceptionState.hadException())
             return;
 
         // Note that m_start.offset() may have changed as a result of container->insertBefore,
         // when the node we are inserting comes before the range in the same container.
         if (collapsed && numNewChildren)
             m_end.set(m_start.container(), m_start.offset() + numNewChildren, lastChild);
     }
 }
 
 String Range::toString() const
 {
     StringBuilder builder;
 
     Node* pastLast = pastLastNode();
     for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
         Node::NodeType type = n->getNodeType();
-        if (type == Node::TEXT_NODE || type == Node::CDATA_SECTION_NODE) {
+        if (type == Node::kTextNode || type == Node::kCdataSectionNode) {
             String data = toCharacterData(n)->data();
             int length = data.length();
             int start = (n == m_start.container()) ? std::min(std::max(0, m_start.offset()), length) : 0;
             int end = (n == m_end.container()) ? std::min(std::max(start, m_end.offset()), length) : length;
             builder.append(data, start, end - start);
         }
     }
 
     return builder.toString();
 }
@@ skipping 49 matching lines @@
 
 
 void Range::detach()
 {
     // This is now a no-op as per the DOM specification.
 }
 
 Node* Range::checkNodeWOffset(Node* n, int offset, ExceptionState& exceptionState) const
 {
     switch (n->getNodeType()) {
-    case Node::DOCUMENT_TYPE_NODE:
+    case Node::kDocumentTypeNode:
         exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
         return nullptr;
-    case Node::CDATA_SECTION_NODE:
-    case Node::COMMENT_NODE:
-    case Node::TEXT_NODE:
+    case Node::kCdataSectionNode:
+    case Node::kCommentNode:
+    case Node::kTextNode:
         if (static_cast<unsigned>(offset) > toCharacterData(n)->length())
             exceptionState.throwDOMException(IndexSizeError, "The offset " + String::number(offset) + " is larger than or equal to the node's length (" + String::number(toCharacterData(n)->length()) + ").");
         return nullptr;
-    case Node::PROCESSING_INSTRUCTION_NODE:
+    case Node::kProcessingInstructionNode:
         if (static_cast<unsigned>(offset) > toProcessingInstruction(n)->data().length())
             exceptionState.throwDOMException(IndexSizeError, "The offset " + String::number(offset) + " is larger than or equal to than the node's length (" + String::number(toProcessingInstruction(n)->data().length()) + ").");
         return nullptr;
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
-    case Node::DOCUMENT_NODE:
-    case Node::ELEMENT_NODE: {
+    case Node::kAttributeNode:
+    case Node::kDocumentFragmentNode:
+    case Node::kDocumentNode:
+    case Node::kElementNode: {
         if (!offset)
             return nullptr;
         Node* childBefore = NodeTraversal::childAt(*n, offset - 1);
         if (!childBefore)
             exceptionState.throwDOMException(IndexSizeError, "There is no child at offset " + String::number(offset) + ".");
         return childBefore;
     }
     }
     ASSERT_NOT_REACHED();
     return nullptr;
@@ skipping 10 matching lines @@
     // InvalidNodeTypeError: Raised if the root container of refNode is not an
     // Attr, Document, DocumentFragment or ShadowRoot node, or part of a SVG shadow DOM tree,
     // or if refNode is a Document, DocumentFragment, ShadowRoot, Attr, Entity, or Notation node.
 
     if (!n->parentNode()) {
         exceptionState.throwDOMException(InvalidNodeTypeError, "the given Node has no parent.");
         return;
     }
 
     switch (n->getNodeType()) {
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
-    case Node::DOCUMENT_NODE:
+    case Node::kAttributeNode:
+    case Node::kDocumentFragmentNode:
+    case Node::kDocumentNode:
         exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
         return;
-    case Node::CDATA_SECTION_NODE:
-    case Node::COMMENT_NODE:
-    case Node::DOCUMENT_TYPE_NODE:
-    case Node::ELEMENT_NODE:
-    case Node::PROCESSING_INSTRUCTION_NODE:
-    case Node::TEXT_NODE:
+    case Node::kCdataSectionNode:
+    case Node::kCommentNode:
+    case Node::kDocumentTypeNode:
+    case Node::kElementNode:
+    case Node::kProcessingInstructionNode:
+    case Node::kTextNode:
         break;
     }
 
     Node* root = n;
     while (ContainerNode* parent = root->parentNode())
         root = parent;
 
     switch (root->getNodeType()) {
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
-    case Node::ELEMENT_NODE:
+    case Node::kAttributeNode:
+    case Node::kDocumentNode:
+    case Node::kDocumentFragmentNode:
+    case Node::kElementNode:
         break;
-    case Node::CDATA_SECTION_NODE:
-    case Node::COMMENT_NODE:
-    case Node::DOCUMENT_TYPE_NODE:
-    case Node::PROCESSING_INSTRUCTION_NODE:
-    case Node::TEXT_NODE:
+    case Node::kCdataSectionNode:
+    case Node::kCommentNode:
+    case Node::kDocumentTypeNode:
+    case Node::kProcessingInstructionNode:
+    case Node::kTextNode:
         exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
         return;
     }
 }
 
 Range* Range::cloneRange() const
 {
     return Range::create(*m_ownerDocument.get(), m_start.container(), m_start.offset(), m_end.container(), m_end.offset());
 }
 
@@ skipping 31 matching lines @@
         exceptionState.throwTypeError("The node provided is null.");
         return;
     }
 
     if (!refNode->parentNode()) {
         exceptionState.throwDOMException(InvalidNodeTypeError, "the given Node has no parent.");
         return;
     }
 
     switch (refNode->getNodeType()) {
-    case Node::CDATA_SECTION_NODE:
-    case Node::COMMENT_NODE:
-    case Node::DOCUMENT_TYPE_NODE:
-    case Node::ELEMENT_NODE:
-    case Node::PROCESSING_INSTRUCTION_NODE:
-    case Node::TEXT_NODE:
+    case Node::kCdataSectionNode:
+    case Node::kCommentNode:
+    case Node::kDocumentTypeNode:
+    case Node::kElementNode:
+    case Node::kProcessingInstructionNode:
+    case Node::kTextNode:
         break;
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
-    case Node::DOCUMENT_NODE:
+    case Node::kAttributeNode:
+    case Node::kDocumentFragmentNode:
+    case Node::kDocumentNode:
         exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + refNode->nodeName() + "'.");
         return;
     }
 
     if (m_ownerDocument != refNode->document())
         setDocument(refNode->document());
 
     setStartBefore(refNode);
     setEndAfter(refNode);
 }
 
 void Range::selectNodeContents(Node* refNode, ExceptionState& exceptionState)
 {
     if (!refNode) {
         // FIXME: Generated bindings code never calls with null, and neither should other callers!
         exceptionState.throwTypeError("The node provided is null.");
         return;
     }
 
     // InvalidNodeTypeError: Raised if refNode or an ancestor of refNode is an Entity, Notation
     // or DocumentType node.
     for (Node* n = refNode; n; n = n->parentNode()) {
         switch (n->getNodeType()) {
-        case Node::ATTRIBUTE_NODE:
-        case Node::CDATA_SECTION_NODE:
-        case Node::COMMENT_NODE:
-        case Node::DOCUMENT_FRAGMENT_NODE:
-        case Node::DOCUMENT_NODE:
-        case Node::ELEMENT_NODE:
-        case Node::PROCESSING_INSTRUCTION_NODE:
-        case Node::TEXT_NODE:
+        case Node::kAttributeNode:
+        case Node::kCdataSectionNode:
+        case Node::kCommentNode:
+        case Node::kDocumentFragmentNode:
+        case Node::kDocumentNode:
+        case Node::kElementNode:
+        case Node::kProcessingInstructionNode:
+        case Node::kTextNode:
             break;
-        case Node::DOCUMENT_TYPE_NODE:
+        case Node::kDocumentTypeNode:
             exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + refNode->nodeName() + "'.");
             return;
         }
     }
 
     if (m_ownerDocument != refNode->document())
         setDocument(refNode->document());
 
     m_start.setToStartOfNode(*refNode);
     m_end.setToEndOfNode(*refNode);
 }
 
 bool Range::selectNodeContents(Node* refNode, Position& start, Position& end)
 {
     if (!refNode) {
         return false;
     }
 
     for (Node* n = refNode; n; n = n->parentNode()) {
         switch (n->getNodeType()) {
-        case Node::ATTRIBUTE_NODE:
-        case Node::CDATA_SECTION_NODE:
-        case Node::COMMENT_NODE:
-        case Node::DOCUMENT_FRAGMENT_NODE:
-        case Node::DOCUMENT_NODE:
-        case Node::ELEMENT_NODE:
-        case Node::PROCESSING_INSTRUCTION_NODE:
-        case Node::TEXT_NODE:
+        case Node::kAttributeNode:
+        case Node::kCdataSectionNode:
+        case Node::kCommentNode:
+        case Node::kDocumentFragmentNode:
+        case Node::kDocumentNode:
+        case Node::kElementNode:
+        case Node::kProcessingInstructionNode:
+        case Node::kTextNode:
             break;
-        case Node::DOCUMENT_TYPE_NODE:
+        case Node::kDocumentTypeNode:
             return false;
         }
     }
 
     RangeBoundaryPoint startBoundaryPoint(refNode);
     startBoundaryPoint.setToStartOfNode(*refNode);
     start = startBoundaryPoint.toPosition();
     RangeBoundaryPoint endBoundaryPoint(refNode);
     endBoundaryPoint.setToEndOfNode(*refNode);
     end = endBoundaryPoint.toPosition();
     return true;
 }
 
 void Range::surroundContents(Node* newParent, ExceptionState& exceptionState)
 {
     if (!newParent) {
         // FIXME: Generated bindings code never calls with null, and neither should other callers!
         exceptionState.throwTypeError("The node provided is null.");
         return;
     }
 
     // InvalidStateError: Raised if the Range partially selects a non-Text node.
     Node* startNonTextContainer = m_start.container();
-    if (startNonTextContainer->getNodeType() == Node::TEXT_NODE)
+    if (startNonTextContainer->getNodeType() == Node::kTextNode)
         startNonTextContainer = startNonTextContainer->parentNode();
     Node* endNonTextContainer = m_end.container();
-    if (endNonTextContainer->getNodeType() == Node::TEXT_NODE)
+    if (endNonTextContainer->getNodeType() == Node::kTextNode)
         endNonTextContainer = endNonTextContainer->parentNode();
     if (startNonTextContainer != endNonTextContainer) {
         exceptionState.throwDOMException(InvalidStateError, "The Range has partially selected a non-Text node.");
         return;
     }
 
     // InvalidNodeTypeError: Raised if node is an Attr, Entity, DocumentType, Notation,
     // Document, or DocumentFragment node.
     switch (newParent->getNodeType()) {
-    case Node::ATTRIBUTE_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
-    case Node::DOCUMENT_NODE:
-    case Node::DOCUMENT_TYPE_NODE:
+    case Node::kAttributeNode:
+    case Node::kDocumentFragmentNode:
+    case Node::kDocumentNode:
+    case Node::kDocumentTypeNode:
         exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + newParent->nodeName() + "'.");
         return;
-    case Node::CDATA_SECTION_NODE:
-    case Node::COMMENT_NODE:
-    case Node::ELEMENT_NODE:
-    case Node::PROCESSING_INSTRUCTION_NODE:
-    case Node::TEXT_NODE:
+    case Node::kCdataSectionNode:
+    case Node::kCommentNode:
+    case Node::kElementNode:
+    case Node::kProcessingInstructionNode:
+    case Node::kTextNode:
         break;
     }
 
     // Raise a HierarchyRequestError if m_start.container() doesn't accept children like newParent.
     Node* parentOfNewParent = m_start.container();
 
     // If m_start.container() is a character data node, it will be split and it will be its parent that will
     // need to accept newParent (or in the case of a comment, it logically "would" be inserted into the parent,
     // although this will fail below for another reason).
     if (parentOfNewParent->isCharacterDataNode())
@@ skipping 413 matching lines @@
 {
     if (range && range->boundaryPointsValid()) {
         range->startContainer()->showTreeAndMark(range->startContainer(), "S", range->endContainer(), "E");
         fprintf(stderr, "start offset: %d, end offset: %d\n", range->startOffset(), range->endOffset());
     } else {
         fprintf(stderr, "Cannot show tree if range is null, or if boundary points are invalid.\n");
     }
 }
 
 #endif