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

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 603 matching lines @@
 }
 
 PassRefPtrWillBeRawPtr<Node> Range::processContentsBetweenOffsets(ActionType action, PassRefPtrWillBeRawPtr<DocumentFragment> fragment,
     Node* container, unsigned startOffset, unsigned endOffset, ExceptionState& exceptionState)
 {
     ASSERT(container);
     ASSERT(startOffset <= endOffset);
 
     // This switch statement must be consistent with that of Node::lengthOfContents.
     RefPtrWillBeRawPtr<Node> result = nullptr;
-    switch (container->nodeType()) {
+    switch (container->getNodeType()) {
     case Node::TEXT_NODE:
     case Node::CDATA_SECTION_NODE:
     case Node::COMMENT_NODE:
     case Node::PROCESSING_INSTRUCTION_NODE:
         endOffset = std::min(endOffset, toCharacterData(container)->length());
         if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
             RefPtrWillBeRawPtr<CharacterData> c = static_pointer_cast<CharacterData>(container->cloneNode(true));
             deleteCharacterData(c, startOffset, endOffset, exceptionState);
             if (fragment) {
                 result = fragment;
@@ skipping 141 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->nodeType();
+    Node::NodeType newNodeType = newNode->getNodeType();
     int numNewChildren;
     if (newNodeType == Node::DOCUMENT_FRAGMENT_NODE && !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->nodeType())) {
+            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;
@@ skipping 67 matching lines @@
             m_end.set(m_start.container(), m_start.offset() + numNewChildren, lastChild.get());
     }
 }
 
 String Range::toString() const
 {
     StringBuilder builder;
 
     Node* pastLast = pastLastNode();
     for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
-        Node::NodeType type = n->nodeType();
+        Node::NodeType type = n->getNodeType();
         if (type == Node::TEXT_NODE || type == Node::CDATA_SECTION_NODE) {
             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->nodeType()) {
+    switch (n->getNodeType()) {
     case Node::DOCUMENT_TYPE_NODE:
         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:
         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:
@@ skipping 26 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->nodeType()) {
+    switch (n->getNodeType()) {
     case Node::ATTRIBUTE_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
     case Node::DOCUMENT_NODE:
         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:
         break;
     }
 
     Node* root = n;
     while (ContainerNode* parent = root->parentNode())
         root = parent;
 
-    switch (root->nodeType()) {
+    switch (root->getNodeType()) {
     case Node::ATTRIBUTE_NODE:
     case Node::DOCUMENT_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
     case Node::ELEMENT_NODE:
         break;
     case Node::CDATA_SECTION_NODE:
     case Node::COMMENT_NODE:
     case Node::DOCUMENT_TYPE_NODE:
     case Node::PROCESSING_INSTRUCTION_NODE:
     case Node::TEXT_NODE:
@@ skipping 40 matching lines @@
         // FIXME: Generated bindings code never calls with null, and neither should other callers!
         exceptionState.throwTypeError("The node provided is null.");
         return;
     }
 
     if (!refNode->parentNode()) {
         exceptionState.throwDOMException(InvalidNodeTypeError, "the given Node has no parent.");
         return;
     }
 
-    switch (refNode->nodeType()) {
+    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:
         break;
     case Node::ATTRIBUTE_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
     case Node::DOCUMENT_NODE:
@@ skipping 12 matching lines @@
 {
     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->nodeType()) {
+        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:
             break;
         case Node::DOCUMENT_TYPE_NODE:
             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->nodeType()) {
+        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:
             break;
         case Node::DOCUMENT_TYPE_NODE:
@@ skipping 14 matching lines @@
 {
     RefPtrWillBeRawPtr<Node> newParent = passNewParent;
     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->nodeType() == Node::TEXT_NODE)
+    if (startNonTextContainer->getNodeType() == Node::TEXT_NODE)
         startNonTextContainer = startNonTextContainer->parentNode();
     Node* endNonTextContainer = m_end.container();
-    if (endNonTextContainer->nodeType() == Node::TEXT_NODE)
+    if (endNonTextContainer->getNodeType() == Node::TEXT_NODE)
         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->nodeType()) {
+    switch (newParent->getNodeType()) {
     case Node::ATTRIBUTE_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
     case Node::DOCUMENT_NODE:
     case Node::DOCUMENT_TYPE_NODE:
         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:
         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())
         parentOfNewParent = parentOfNewParent->parentNode();
 
     if (!parentOfNewParent) {
         exceptionState.throwDOMException(HierarchyRequestError, "The container node is a detached character data node; no parent node is available for insertion.");
         return;
     }
 
-    if (!parentOfNewParent->childTypeAllowed(newParent->nodeType())) {
+    if (!parentOfNewParent->childTypeAllowed(newParent->getNodeType())) {
         exceptionState.throwDOMException(HierarchyRequestError, "The node provided is of type '" + newParent->nodeName() + "', which may not be inserted here.");
         return;
     }
 
     if (newParent->containsIncludingShadowDOM(m_start.container())) {
         exceptionState.throwDOMException(HierarchyRequestError, "The node provided contains the insertion point; it may not be inserted into itself.");
         return;
     }
 
     // FIXME: Do we need a check if the node would end up with a child node of a type not
@@ skipping 437 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