Rename Blink constants generated from IDL files.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 816 matching lines @@
         if (exceptionState.hadException())
             return false;
     }
 
     return true;
 }
 
 Node* Document::importNode(Node* importedNode, bool deep, ExceptionState& exceptionState)
 {
     switch (importedNode->getNodeType()) {
-    case TEXT_NODE:
+    case kTextNode:
         return createTextNode(importedNode->nodeValue());
-    case CDATA_SECTION_NODE:
+    case kCdataSectionNode:
         return CDATASection::create(*this, importedNode->nodeValue());
-    case PROCESSING_INSTRUCTION_NODE:
+    case kProcessingInstructionNode:
         return createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue(), exceptionState);
-    case COMMENT_NODE:
+    case kCommentNode:
         return createComment(importedNode->nodeValue());
-    case DOCUMENT_TYPE_NODE: {
+    case kDocumentTypeNode: {
         DocumentType* doctype = toDocumentType(importedNode);
         return DocumentType::create(this, doctype->name(), doctype->publicId(), doctype->systemId());
     }
-    case ELEMENT_NODE: {
+    case kElementNode: {
         Element* oldElement = toElement(importedNode);
         // FIXME: The following check might be unnecessary. Is it possible that
         // oldElement has mismatched prefix/namespace?
         if (!hasValidNamespaceForElements(oldElement->tagQName())) {
             exceptionState.throwDOMException(NamespaceError, "The imported node has an invalid namespace.");
             return nullptr;
         }
         Element* newElement = createElement(oldElement->tagQName(), CreatedByImportNode);
 
         newElement->cloneDataFromElement(*oldElement);
 
         if (deep) {
             if (!importContainerNodeChildren(oldElement, newElement, exceptionState))
                 return nullptr;
             if (isHTMLTemplateElement(*oldElement)
                 && !ensureTemplateDocument().importContainerNodeChildren(
                     toHTMLTemplateElement(oldElement)->content(),
                     toHTMLTemplateElement(newElement)->content(), exceptionState))
                 return nullptr;
         }
 
         return newElement;
     }
-    case ATTRIBUTE_NODE:
+    case kAttributeNode:
         return Attr::create(*this, QualifiedName(nullAtom, AtomicString(toAttr(importedNode)->name()), nullAtom), toAttr(importedNode)->value());
-    case DOCUMENT_FRAGMENT_NODE: {
+    case kDocumentFragmentNode: {
         if (importedNode->isShadowRoot()) {
             // ShadowRoot nodes should not be explicitly importable.
             // Either they are imported along with their host node, or created implicitly.
             exceptionState.throwDOMException(NotSupportedError, "The node provided is a shadow root, which may not be imported.");
             return nullptr;
         }
         DocumentFragment* oldFragment = toDocumentFragment(importedNode);
         DocumentFragment* newFragment = createDocumentFragment();
         if (deep && !importContainerNodeChildren(oldFragment, newFragment, exceptionState))
             return nullptr;
 
         return newFragment;
     }
-    case DOCUMENT_NODE:
+    case kDocumentNode:
         exceptionState.throwDOMException(NotSupportedError, "The node provided is a document, which may not be imported.");
         return nullptr;
     }
 
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 Node* Document::adoptNode(Node* source, ExceptionState& exceptionState)
 {
     EventQueueScope scope;
 
     switch (source->getNodeType()) {
-    case DOCUMENT_NODE:
+    case kDocumentNode:
         exceptionState.throwDOMException(NotSupportedError, "The node provided is of type '" + source->nodeName() + "', which may not be adopted.");
         return nullptr;
-    case ATTRIBUTE_NODE: {
+    case kAttributeNode: {
         Attr* attr = toAttr(source);
         if (Element* ownerElement = attr->ownerElement())
             ownerElement->removeAttributeNode(attr, exceptionState);
         break;
     }
     default:
         if (source->isShadowRoot()) {
             // ShadowRoot cannot disconnect itself from the host node.
             exceptionState.throwDOMException(HierarchyRequestError, "The node provided is a shadow root, which may not be adopted.");
             return nullptr;
@@ skipping 425 matching lines @@
         m_canvasFontCache->pruneAll();
 }
 
 String Document::nodeName() const
 {
     return "#document";
 }
 
 Node::NodeType Document::getNodeType() const
 {
-    return DOCUMENT_NODE;
+    return kDocumentNode;
 }
 
 FormController& Document::formController()
 {
     if (!m_formController) {
         m_formController = FormController::create();
         if (m_frame && m_frame->loader().currentItem() && m_frame->loader().currentItem()->isCurrentDocument(this))
             m_frame->loader().currentItem()->setDocumentState(m_formController->formElementsState());
     }
     return *m_formController;
@@ skipping 1818 matching lines @@
         return MouseEventWithHitTestResults(eventWithRegion, result);
     }
 
     return MouseEventWithHitTestResults(event, result);
 }
 
 // DOM Section 1.1.1
 bool Document::childTypeAllowed(NodeType type) const
 {
     switch (type) {
-    case ATTRIBUTE_NODE:
-    case CDATA_SECTION_NODE:
-    case DOCUMENT_FRAGMENT_NODE:
-    case DOCUMENT_NODE:
-    case TEXT_NODE:
+    case kAttributeNode:
+    case kCdataSectionNode:
+    case kDocumentFragmentNode:
+    case kDocumentNode:
+    case kTextNode:
         return false;
-    case COMMENT_NODE:
-    case PROCESSING_INSTRUCTION_NODE:
+    case kCommentNode:
+    case kProcessingInstructionNode:
         return true;
-    case DOCUMENT_TYPE_NODE:
-    case ELEMENT_NODE:
+    case kDocumentTypeNode:
+    case kElementNode:
         // Documents may contain no more than one of each of these.
         // (One Element and one DocumentType.)
         for (Node& c : NodeTraversal::childrenOf(*this)) {
             if (c.getNodeType() == type)
                 return false;
         }
         return true;
     }
     return false;
 }
 
 bool Document::canAcceptChild(const Node& newChild, const Node* oldChild, ExceptionState& exceptionState) const
 {
     if (oldChild && oldChild->getNodeType() == newChild.getNodeType())
         return true;
 
     int numDoctypes = 0;
     int numElements = 0;
 
     // First, check how many doctypes and elements we have, not counting
     // the child we're about to remove.
     for (Node& child : NodeTraversal::childrenOf(*this)) {
         if (oldChild && *oldChild == child)
             continue;
 
         switch (child.getNodeType()) {
-        case DOCUMENT_TYPE_NODE:
+        case kDocumentTypeNode:
             numDoctypes++;
             break;
-        case ELEMENT_NODE:
+        case kElementNode:
             numElements++;
             break;
         default:
             break;
         }
     }
 
     // Then, see how many doctypes and elements might be added by the new child.
     if (newChild.isDocumentFragment()) {
         for (Node& child : NodeTraversal::childrenOf(toDocumentFragment(newChild))) {
             switch (child.getNodeType()) {
-            case ATTRIBUTE_NODE:
-            case CDATA_SECTION_NODE:
-            case DOCUMENT_FRAGMENT_NODE:
-            case DOCUMENT_NODE:
-            case TEXT_NODE:
+            case kAttributeNode:
+            case kCdataSectionNode:
+            case kDocumentFragmentNode:
+            case kDocumentNode:
+            case kTextNode:
                 exceptionState.throwDOMException(HierarchyRequestError, "Nodes of type '" + newChild.nodeName() +
                     "' may not be inserted inside nodes of type '#document'.");
                 return false;
-            case COMMENT_NODE:
-            case PROCESSING_INSTRUCTION_NODE:
+            case kCommentNode:
+            case kProcessingInstructionNode:
                 break;
-            case DOCUMENT_TYPE_NODE:
+            case kDocumentTypeNode:
                 numDoctypes++;
                 break;
-            case ELEMENT_NODE:
+            case kElementNode:
                 numElements++;
                 break;
             }
         }
     } else {
         switch (newChild.getNodeType()) {
-        case ATTRIBUTE_NODE:
-        case CDATA_SECTION_NODE:
-        case DOCUMENT_FRAGMENT_NODE:
-        case DOCUMENT_NODE:
-        case TEXT_NODE:
+        case kAttributeNode:
+        case kCdataSectionNode:
+        case kDocumentFragmentNode:
+        case kDocumentNode:
+        case kTextNode:
             exceptionState.throwDOMException(HierarchyRequestError, "Nodes of type '" + newChild.nodeName() +
                 "' may not be inserted inside nodes of type '#document'.");
             return false;
-        case COMMENT_NODE:
-        case PROCESSING_INSTRUCTION_NODE:
+        case kCommentNode:
+        case kProcessingInstructionNode:
             return true;
-        case DOCUMENT_TYPE_NODE:
+        case kDocumentTypeNode:
             numDoctypes++;
             break;
-        case ELEMENT_NODE:
+        case kElementNode:
             numElements++;
             break;
         }
     }
 
     if (numElements > 1 || numDoctypes > 1) {
         exceptionState.throwDOMException(HierarchyRequestError,
             String::format("Only one %s on document allowed.",
             numElements > 1 ? "element" : "doctype"));
         return false;
@@ skipping 2758 matching lines @@
 }
 
 void showLiveDocumentInstances()
 {
     WeakDocumentSet& set = liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().getString().utf8().data());
 }
 #endif