Remove more API from Node and ContainerNode.

sky/engine/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 70 matching lines @@
 #include "platform/TracedValue.h"
 #include "wtf/HashSet.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefCountedLeakCounter.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
-struct SameSizeAsNode : NODE_BASE_CLASSES {
+struct SameSizeAsNode : public EventTarget, public TreeShared<Node> {
     uint32_t m_nodeFlags;
     void* m_pointer[5];
 };
 
 COMPILE_ASSERT(sizeof(Node) <= sizeof(SameSizeAsNode), Node_should_stay_small);
 
 #if !ENABLE(OILPAN)
 void* Node::operator new(size_t size)
 {
     ASSERT(isMainThread());
@@ skipping 206 matching lines @@
         m_data.m_rareData = ElementRareData::create(m_data.m_renderer);
     else
         m_data.m_rareData = NodeRareData::create(m_data.m_renderer);
 
     ASSERT(m_data.m_rareData);
 
     setFlag(HasRareDataFlag);
     return *rareData();
 }
 
-#if !ENABLE(OILPAN)
 void Node::clearRareData()
 {
     ASSERT(hasRareData());
     ASSERT(!transientMutationObserverRegistry() || transientMutationObserverRegistry()->isEmpty());
 
     RenderObject* renderer = m_data.m_rareData->renderer();
     if (isElementNode())
         delete static_cast<ElementRareData*>(m_data.m_rareData);
     else
         delete static_cast<NodeRareData*>(m_data.m_rareData);
     m_data.m_renderer = renderer;
     clearFlag(HasRareDataFlag);
 }
-#endif
 
 Node* Node::toNode()
 {
     return this;
 }
 
 short Node::tabIndex() const
 {
     return 0;
 }
 
-String Node::nodeValue() const
-{
-    return String();
-}
-
-void Node::setNodeValue(const String&)
-{
-    // By default, setting nodeValue has no effect.
-}
-
 PassRefPtr<Node> Node::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionState& exceptionState)
 {
     if (isContainerNode())
         return toContainerNode(this)->insertBefore(newChild, refChild, exceptionState);
 
     exceptionState.throwDOMException(HierarchyRequestError, "This node type does not support this method.");
     return nullptr;
 }
 
 PassRefPtr<Node> Node::replaceChild(PassRefPtr<Node> newChild, PassRefPtr<Node> oldChild, ExceptionState& exceptionState)
@@ skipping 648 matching lines @@
     NodeType nodeType = this->nodeType();
     if (nodeType != other->nodeType())
         return false;
 
     if (nodeName() != other->nodeName())
         return false;
 
     if (localName() != other->localName())
         return false;
 
-    if (nodeValue() != other->nodeValue())
-        return false;
-
     if (isElementNode() && !toElement(this)->hasEquivalentAttributes(toElement(other)))
         return false;
 
     Node* child = firstChild();
     Node* otherChild = other->firstChild();
 
     while (child) {
         if (!child->isEqualNode(otherChild))
             return false;
 
@@ skipping 23 matching lines @@
 {
     StringBuilder content;
     appendTextContent(this, convertBRsToNewlines, content);
     return content.toString();
 }
 
 void Node::setTextContent(const String& text)
 {
     switch (nodeType()) {
         case TEXT_NODE:
-            setNodeValue(text);
+            toText(this)->setData(text);
             return;
         case ELEMENT_NODE:
         case DOCUMENT_FRAGMENT_NODE: {
             // FIXME: Merge this logic into replaceChildrenWithText.
             RefPtr<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)
@@ skipping 149 matching lines @@
     stringBuilder.appendLiteral("=\"");
     stringBuilder.append(attr);
     stringBuilder.appendLiteral("\"");
 }
 
 void Node::showNode(const char* prefix) const
 {
     if (!prefix)
         prefix = "";
     if (isTextNode()) {
-        String value = nodeValue();
+        String value = toText(this)->data();
         value.replaceWithLiteral('\\', "\\\\");
         value.replaceWithLiteral('\n', "\\n");
         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
     } else {
         StringBuilder attrs;
         appendAttributeDesc(this, attrs, HTMLNames::idAttr, " ID");
         appendAttributeDesc(this, attrs, HTMLNames::classAttr, " CLASS");
         appendAttributeDesc(this, attrs, HTMLNames::styleAttr, " STYLE");
         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.toString().utf8().data());
     }
@@ skipping 253 matching lines @@
 EventTargetData& Node::ensureEventTargetData()
 {
     if (hasEventTargetData())
         return *eventTargetDataMap().get(this);
     setHasEventTargetData(true);
     EventTargetData* data = new EventTargetData;
     eventTargetDataMap().set(this, adoptPtr(data));
     return *data;
 }
 
-#if !ENABLE(OILPAN)
 void Node::clearEventTargetData()
 {
     eventTargetDataMap().remove(this);
 }
-#endif
 
 Vector<OwnPtr<MutationObserverRegistration> >* Node::mutationObserverRegistry()
 {
     if (!hasRareData())
         return 0;
     NodeMutationObserverData* data = rareData()->mutationObserverData();
     if (!data)
         return 0;
     return &data->registry;
 }
@@ skipping 63 matching lines @@
 
     size_t index = registry->find(registration);
     ASSERT(index != kNotFound);
     if (index == kNotFound)
         return;
 
     // Deleting the registration may cause this node to be derefed, so we must make sure the Vector operation completes
     // before that, in case |this| is destroyed (see MutationObserverRegistration::m_registrationNodeKeepAlive).
     // FIXME: Simplify the registration/transient registration logic to make this understandable by humans.
     RefPtr<Node> protect(this);
-#if ENABLE(OILPAN)
-    // The explicit dispose() is needed to have the registration
-    // object unregister itself promptly.
-    registration->dispose();
-#endif
     registry->remove(index);
 }
 
 void Node::registerTransientMutationObserver(MutationObserverRegistration* registration)
 {
     ensureRareData().ensureMutationObserverData().transientRegistry.add(registration);
 }
 
 void Node::unregisterTransientMutationObserver(MutationObserverRegistration* registration)
 {
@@ skipping 271 matching lines @@
     }
 
     ASSERT(isHTMLElement());
     setFlag(CustomElementFlag);
     setFlag(newState == Upgraded, CustomElementUpgradedFlag);
 
     if (oldState == NotCustomElement || newState == Upgraded)
         setNeedsStyleRecalc(SubtreeStyleChange); // :unresolved has changed
 }
 
-void Node::trace(Visitor* visitor)
-{
-#if ENABLE(OILPAN)
-    visitor->trace(m_parentOrShadowHostNode);
-    visitor->trace(m_previous);
-    visitor->trace(m_next);
-    // rareData() and m_data.m_renderer share their storage. We have to trace
-    // only one of them.
-    if (hasRareData())
-        visitor->trace(rareData());
-    else
-        visitor->trace(m_data.m_renderer);
-    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()) {
     case Node::TEXT_NODE:
         return toCharacterData(this)->length();
     case Node::ELEMENT_NODE:
     case Node::DOCUMENT_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
         return toContainerNode(this)->countChildren();
@@ skipping 34 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif