Merge the Sky Engine changes from the SkyDart branch

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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "sky/engine/config.h"
 #include "sky/engine/core/dom/Node.h"
 
 #include "base/trace_event/trace_event_impl.h"
 #include "gen/sky/core/HTMLNames.h"
-#include "sky/engine/bindings/core/v8/DOMDataStore.h"
-#include "sky/engine/bindings/core/v8/ExceptionState.h"
-#include "sky/engine/bindings/core/v8/ScriptCallStackFactory.h"
-#include "sky/engine/bindings/core/v8/V8DOMWrapper.h"
+#include "sky/engine/bindings2/exception_state.h"
 #include "sky/engine/core/css/resolver/StyleResolver.h"
 #include "sky/engine/core/dom/Attr.h"
 #include "sky/engine/core/dom/Attribute.h"
 #include "sky/engine/core/dom/ChildListMutationScope.h"
 #include "sky/engine/core/dom/Document.h"
 #include "sky/engine/core/dom/DocumentFragment.h"
 #include "sky/engine/core/dom/DocumentMarkerController.h"
 #include "sky/engine/core/dom/Element.h"
 #include "sky/engine/core/dom/ElementRareData.h"
 #include "sky/engine/core/dom/ElementTraversal.h"
@@ skipping 23 matching lines @@
 #include "sky/engine/core/frame/Settings.h"
 #include "sky/engine/core/html/HTMLAnchorElement.h"
 #include "sky/engine/core/html/HTMLStyleElement.h"
 #include "sky/engine/core/page/EventHandler.h"
 #include "sky/engine/core/page/Page.h"
 #include "sky/engine/core/rendering/RenderBox.h"
 #include "sky/engine/platform/EventDispatchForbiddenScope.h"
 #include "sky/engine/platform/JSONValues.h"
 #include "sky/engine/platform/Partitions.h"
 #include "sky/engine/platform/TraceEvent.h"
+#include "sky/engine/tonic/dart_gc_visitor.h"
 #include "sky/engine/wtf/HashSet.h"
 #include "sky/engine/wtf/PassOwnPtr.h"
 #include "sky/engine/wtf/RefCountedLeakCounter.h"
 #include "sky/engine/wtf/Vector.h"
 #include "sky/engine/wtf/text/CString.h"
 #include "sky/engine/wtf/text/StringBuilder.h"
 
 namespace blink {
 
 struct SameSizeAsNode : public EventTarget, public TreeShared<Node> {
@@ skipping 226 matching lines @@
 
     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);
 }
 
+static const Node* rootForGC(const Node* node)
+{
+    if (node->inDocument())
+        return &node->document();
+    while (Node* parent = node->parentOrShadowHostOrTemplateHostNode())
+        node = parent;
+    return node;
+}
+
+void Node::AcceptDartGCVisitor(DartGCVisitor& visitor) const
+{
+    visitor.AddToSetForRoot(rootForGC(this), dart_wrapper());
+    EventTarget::AcceptDartGCVisitor(visitor);
+}
+
 Node* Node::toNode()
 {
     return this;
 }
 
 short Node::tabIndex() const
 {
     return 0;
 }
 
 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.");
+    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)
 {
     if (isContainerNode())
         return toContainerNode(this)->replaceChild(newChild, oldChild, exceptionState);
 
-    exceptionState.throwDOMException(HierarchyRequestError,  "This node type does not support this method.");
+    exceptionState.ThrowDOMException(HierarchyRequestError,  "This node type does not support this method.");
     return nullptr;
 }
 
 PassRefPtr<Node> Node::removeChild(PassRefPtr<Node> oldChild, ExceptionState& exceptionState)
 {
     if (isContainerNode())
         return toContainerNode(this)->removeChild(oldChild, exceptionState);
 
-    exceptionState.throwDOMException(NotFoundError, "This node type does not support this method.");
+    exceptionState.ThrowDOMException(NotFoundError, "This node type does not support this method.");
     return nullptr;
 }
 
 PassRefPtr<Node> Node::appendChild(PassRefPtr<Node> newChild, ExceptionState& exceptionState)
 {
     if (isContainerNode())
         return toContainerNode(this)->appendChild(newChild, exceptionState);
 
-    exceptionState.throwDOMException(HierarchyRequestError, "This node type does not support this method.");
+    exceptionState.ThrowDOMException(HierarchyRequestError, "This node type does not support this method.");
     return nullptr;
 }
 
 void Node::remove(ExceptionState& exceptionState)
 {
     if (ContainerNode* parent = parentNode())
         parent->removeChild(this, exceptionState);
 }
 
 const AtomicString& Node::localName() const
@@ skipping 99 matching lines @@
 
     void AppendAsTraceFormat(std::string* out) const override
     {
         out->append(m_value->toJSONString().utf8().data());
     }
 
 private:
     RefPtr<JSONValue> m_value;
 };
 
-void addJsStack(JSONArray* stackFrames)
-{
-    RefPtr<ScriptCallStack> stack = createScriptCallStack(10);
-    if (!stack)
-        return;
-    for (size_t i = 0; i < stack->size(); i++)
-        stackFrames->pushString(stack->at(i).functionName());
-}
-
-scoped_refptr<base::debug::ConvertableToTraceFormat> jsonObjectForStyleInvalidation(unsigned nodeCount, const Node* rootNode)
-{
-    RefPtr<JSONObject> value = JSONObject::create();
-    value->setNumber("node_count", nodeCount);
-    value->setString("root_node", rootNode->debugName());
-    RefPtr<JSONArray> stack;
-    addJsStack(stack.get());
-    value->setArray("js_stack", stack.release());
-    return make_scoped_refptr(new JSONTraceValue(value));
-}
-
 } // namespace
 
 unsigned Node::styledSubtreeSize() const
 {
     unsigned nodeCount = 0;
 
     for (const Node* node = this; node; node = NodeTraversal::next(*node, this)) {
         if (node->isTextNode() || node->isElementNode())
             nodeCount++;
         if (ShadowRoot* root = node->shadowRoot())
             nodeCount += root->styledSubtreeSize();
     }
 
     return nodeCount;
 }
 
 void Node::traceStyleChange(StyleChangeType changeType)
 {
     static const unsigned kMinLoggedSize = 100;
     unsigned nodeCount = styledSubtreeSize();
     if (nodeCount < kMinLoggedSize)
         return;
 
-    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("style.debug"),
-        "Node::setNeedsStyleRecalc", TRACE_EVENT_SCOPE_PROCESS,
-        "data", jsonObjectForStyleInvalidation(nodeCount, this)
+    TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("style.debug"),
+        "Node::setNeedsStyleRecalc", TRACE_EVENT_SCOPE_PROCESS
     );
 }
 
 void Node::traceStyleChangeIfNeeded(StyleChangeType changeType)
 {
     // TRACE_EVENT_CATEGORY_GROUP_ENABLED macro loads a global static bool into our local bool.
     bool styleTracingEnabled;
     TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("style.debug"), &styleTracingEnabled);
     if (UNLIKELY(styleTracingEnabled))
         traceStyleChange(changeType);
@@ skipping 1054 matching lines @@
         return toCharacterData(this)->length();
     case Node::ELEMENT_NODE:
     case Node::DOCUMENT_NODE:
     case Node::DOCUMENT_FRAGMENT_NODE:
         return toContainerNode(this)->countChildren();
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
-v8::Handle<v8::Object> Node::wrap(v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
-{
-    ASSERT(!DOMDataStore::containsWrapperNonTemplate(this, isolate));
-
-    const WrapperTypeInfo* wrapperType = wrapperTypeInfo();
-
-    v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, wrapperType, toScriptWrappableBase(), isolate);
-    if (UNLIKELY(wrapper.IsEmpty()))
-        return wrapper;
-
-    wrapperType->installConditionallyEnabledProperties(wrapper, isolate);
-    V8DOMWrapper::associateObjectWithWrapperNonTemplate(this, wrapperType, wrapper, isolate);
-    return wrapper;
-}
-
 } // namespace blink
 
 #ifndef NDEBUG
 
 void showNode(const blink::Node* node)
 {
     if (node)
         node->showNode("");
 }
 
 void showTree(const blink::Node* node)
 {
     if (node)
         node->showTreeForThis();
 }
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif