auto merge of #1189 : Ms2ger/servo/new-node, r=jdm

src/components/script/dom/bindings/node.rs

@@ -3,11 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::utils::{Reflectable, Reflector, Traceable};
-use dom::document::{PlainDocumentTypeId, HTMLDocumentTypeId};
-use dom::element::*;
 use dom::types::*;
-use dom::node::{AbstractNode, ElementNodeTypeId, TextNodeTypeId, CommentNodeTypeId};
+use dom::node::{AbstractNode, ScriptView};
-use dom::node::{DoctypeNodeTypeId, DocumentFragmentNodeTypeId, ScriptView, DocumentNodeTypeId};
 
 use std::cast;
 use std::libc;
@@ -15,93 +12,6 @@ use std::ptr;
 use js::jsapi::{JSContext, JSObject, JSTracer, JSTRACE_OBJECT, JS_CallTracer};
 use servo_util::tree::TreeNodeRef;
 
-macro_rules! generate_element(
-    ($name: path) => ({
-        let node: @mut $name = unsafe { cast::transmute(node.raw_object()) };
-        node.wrap_object_shared(cx, ptr::null())
-    })
-)
-
-pub fn create(cx: *JSContext, node: &mut AbstractNode<ScriptView>) -> *JSObject {
-    match node.type_id() {
-        ElementNodeTypeId(HTMLElementTypeId) => generate_element!(HTMLElement),
-        ElementNodeTypeId(HTMLAnchorElementTypeId) => generate_element!(HTMLAnchorElement),
-        ElementNodeTypeId(HTMLAppletElementTypeId) => generate_element!(HTMLAppletElement),
-        ElementNodeTypeId(HTMLAreaElementTypeId) => generate_element!(HTMLAreaElement),
-        ElementNodeTypeId(HTMLAudioElementTypeId) => generate_element!(HTMLAudioElement),
-        ElementNodeTypeId(HTMLBaseElementTypeId) => generate_element!(HTMLBaseElement),
-        ElementNodeTypeId(HTMLBodyElementTypeId) => generate_element!(HTMLBodyElement),
-        ElementNodeTypeId(HTMLBRElementTypeId) => generate_element!(HTMLBRElement),
-        ElementNodeTypeId(HTMLButtonElementTypeId) => generate_element!(HTMLButtonElement),
-        ElementNodeTypeId(HTMLCanvasElementTypeId) => generate_element!(HTMLCanvasElement),
-        ElementNodeTypeId(HTMLDataElementTypeId) => generate_element!(HTMLDataElement),
-        ElementNodeTypeId(HTMLDataListElementTypeId) => generate_element!(HTMLDataListElement),
-        ElementNodeTypeId(HTMLDirectoryElementTypeId) => generate_element!(HTMLDirectoryElement),
-        ElementNodeTypeId(HTMLDListElementTypeId) => generate_element!(HTMLDListElement),
-        ElementNodeTypeId(HTMLDivElementTypeId) => generate_element!(HTMLDivElement),
-        ElementNodeTypeId(HTMLEmbedElementTypeId) => generate_element!(HTMLEmbedElement),
-        ElementNodeTypeId(HTMLFieldSetElementTypeId) => generate_element!(HTMLFieldSetElement),
-        ElementNodeTypeId(HTMLFontElementTypeId) => generate_element!(HTMLFontElement),
-        ElementNodeTypeId(HTMLFormElementTypeId) => generate_element!(HTMLFormElement),
-        ElementNodeTypeId(HTMLFrameElementTypeId) => generate_element!(HTMLFrameElement),
-        ElementNodeTypeId(HTMLFrameSetElementTypeId) => generate_element!(HTMLFrameSetElement),
-        ElementNodeTypeId(HTMLHeadElementTypeId) => generate_element!(HTMLHeadElement),
-        ElementNodeTypeId(HTMLHeadingElementTypeId) => generate_element!(HTMLHeadingElement),
-        ElementNodeTypeId(HTMLHRElementTypeId) => generate_element!(HTMLHRElement),
-        ElementNodeTypeId(HTMLHtmlElementTypeId) => generate_element!(HTMLHtmlElement),
-        ElementNodeTypeId(HTMLIframeElementTypeId) => generate_element!(HTMLIFrameElement),
-        ElementNodeTypeId(HTMLImageElementTypeId) => generate_element!(HTMLImageElement),
-        ElementNodeTypeId(HTMLInputElementTypeId) => generate_element!(HTMLInputElement),
-        ElementNodeTypeId(HTMLLabelElementTypeId) => generate_element!(HTMLLabelElement),
-        ElementNodeTypeId(HTMLLegendElementTypeId) => generate_element!(HTMLLegendElement),
-        ElementNodeTypeId(HTMLLIElementTypeId) => generate_element!(HTMLLIElement),
-        ElementNodeTypeId(HTMLLinkElementTypeId) => generate_element!(HTMLLinkElement),
-        ElementNodeTypeId(HTMLMainElementTypeId) => generate_element!(HTMLMainElement),
-        ElementNodeTypeId(HTMLMapElementTypeId) => generate_element!(HTMLMapElement),
-        ElementNodeTypeId(HTMLMediaElementTypeId) => generate_element!(HTMLMediaElement),
-        ElementNodeTypeId(HTMLMetaElementTypeId) => generate_element!(HTMLMetaElement),
-        ElementNodeTypeId(HTMLMeterElementTypeId) => generate_element!(HTMLMeterElement),
-        ElementNodeTypeId(HTMLModElementTypeId) => generate_element!(HTMLModElement),
-        ElementNodeTypeId(HTMLObjectElementTypeId) => generate_element!(HTMLObjectElement),
-        ElementNodeTypeId(HTMLOListElementTypeId) => generate_element!(HTMLOListElement),
-        ElementNodeTypeId(HTMLOptGroupElementTypeId) => generate_element!(HTMLOptGroupElement),
-        ElementNodeTypeId(HTMLOptionElementTypeId) => generate_element!(HTMLOptionElement),
-        ElementNodeTypeId(HTMLOutputElementTypeId) => generate_element!(HTMLOutputElement),
-        ElementNodeTypeId(HTMLParagraphElementTypeId) => generate_element!(HTMLParagraphElement),
-        ElementNodeTypeId(HTMLParamElementTypeId) => generate_element!(HTMLParamElement),
-        ElementNodeTypeId(HTMLPreElementTypeId) => generate_element!(HTMLPreElement),
-        ElementNodeTypeId(HTMLProgressElementTypeId) => generate_element!(HTMLProgressElement),
-        ElementNodeTypeId(HTMLQuoteElementTypeId) => generate_element!(HTMLQuoteElement),
-        ElementNodeTypeId(HTMLScriptElementTypeId) => generate_element!(HTMLScriptElement),
-        ElementNodeTypeId(HTMLSelectElementTypeId) => generate_element!(HTMLSelectElement),
-        ElementNodeTypeId(HTMLSourceElementTypeId) => generate_element!(HTMLSourceElement),
-        ElementNodeTypeId(HTMLSpanElementTypeId) => generate_element!(HTMLSpanElement),
-        ElementNodeTypeId(HTMLStyleElementTypeId) => generate_element!(HTMLStyleElement),
-        ElementNodeTypeId(HTMLTableElementTypeId) => generate_element!(HTMLTableElement),
-        ElementNodeTypeId(HTMLTableCellElementTypeId) => generate_element!(HTMLTableCellElement),
-        ElementNodeTypeId(HTMLTableDataCellElementTypeId) => generate_element!(HTMLTableDataCellElement),
-        ElementNodeTypeId(HTMLTableHeaderCellElementTypeId) => generate_element!(HTMLTableHeaderCellElement),
-        ElementNodeTypeId(HTMLTableCaptionElementTypeId) => generate_element!(HTMLTableCaptionElement),
-        ElementNodeTypeId(HTMLTableColElementTypeId) => generate_element!(HTMLTableColElement),
-        ElementNodeTypeId(HTMLTableRowElementTypeId) => generate_element!(HTMLTableRowElement),
-        ElementNodeTypeId(HTMLTableSectionElementTypeId) => generate_element!(HTMLTableSectionElement),
-        ElementNodeTypeId(HTMLTemplateElementTypeId) => generate_element!(HTMLTemplateElement),
-        ElementNodeTypeId(HTMLTextAreaElementTypeId) => generate_element!(HTMLTextAreaElement),
-        ElementNodeTypeId(HTMLTimeElementTypeId) => generate_element!(HTMLTimeElement),
-        ElementNodeTypeId(HTMLTitleElementTypeId) => generate_element!(HTMLTitleElement),
-        ElementNodeTypeId(HTMLTrackElementTypeId) => generate_element!(HTMLTrackElement),
-        ElementNodeTypeId(HTMLUListElementTypeId) => generate_element!(HTMLUListElement),
-        ElementNodeTypeId(HTMLVideoElementTypeId) => generate_element!(HTMLVideoElement),
-        ElementNodeTypeId(HTMLUnknownElementTypeId) => generate_element!(HTMLUnknownElement),
-        CommentNodeTypeId => generate_element!(Comment),
-        DoctypeNodeTypeId => generate_element!(DocumentType),
-        DocumentFragmentNodeTypeId => generate_element!(DocumentFragment),
-        DocumentNodeTypeId(PlainDocumentTypeId) => generate_element!(Document),
-        DocumentNodeTypeId(HTMLDocumentTypeId) => generate_element!(HTMLDocument),
-        TextNodeTypeId => generate_element!(Text),
-    }
-}
-
 impl Reflectable for AbstractNode<ScriptView> {
     fn reflector<'a>(&'a self) -> &'a Reflector {
         self.node().reflector()

src/components/script/dom/bindings/utils.rs

@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::PrototypeList;
 use dom::bindings::codegen::PrototypeList::MAX_PROTO_CHAIN_LENGTH;
-use dom::bindings::node;
 use dom::window;
 use dom::node::{AbstractNode, ScriptView};
 
@@ -754,14 +753,11 @@ pub trait DerivedWrapper {
 
 impl DerivedWrapper for AbstractNode<ScriptView> {
     #[fixed_stack_segment]
-    fn wrap(&mut self, cx: *JSContext, _scope: *JSObject, vp: *mut JSVal) -> i32 {
+    fn wrap(&mut self, _cx: *JSContext, _scope: *JSObject, vp: *mut JSVal) -> i32 {
         let obj = self.reflector().get_jsobject();
-        if obj.is_not_null() {
+        assert!(obj.is_not_null());
-            unsafe { *vp = RUST_OBJECT_TO_JSVAL(obj) };
+        unsafe { *vp = RUST_OBJECT_TO_JSVAL(obj) };
-            return 1;
+        return true as i32;
-        }
-        unsafe { *vp = RUST_OBJECT_TO_JSVAL(node::create(cx, self)) };
-        return 1;
     }
 }
 

src/components/script/dom/comment.rs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::codegen::CommentBinding;
 use dom::bindings::utils::{DOMString, Fallible, null_str_as_empty};
 use dom::characterdata::CharacterData;
 use dom::document::AbstractDocument;
@@ -14,17 +15,18 @@ pub struct Comment {
 }
 
 impl Comment {
-    /// Creates a new HTML comment.
+    pub fn new_inherited(text: ~str, document: AbstractDocument) -> Comment {
-    pub fn new(text: ~str, document: AbstractDocument) -> Comment {
         Comment {
             element: CharacterData::new(CommentNodeTypeId, text, document)
         }
     }
 
+    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+        let node = Comment::new_inherited(text, document);
+        Node::reflect_node(@mut node, document, CommentBinding::Wrap)
+    }
+
     pub fn Constructor(owner: @mut Window, data: &DOMString) -> Fallible<AbstractNode<ScriptView>> {
-        let s = null_str_as_empty(data);
+        Ok(Comment::new(null_str_as_empty(data), owner.Document()))
-        let cx = owner.get_cx();
-        let comment = @Comment::new(s, owner.Document());
-        Ok(unsafe { Node::as_abstract_node(cx, comment) })
     }
 }

src/components/script/dom/document.rs

@@ -244,21 +244,15 @@ impl Document {
     }
 
     pub fn CreateDocumentFragment(&self, abstract_self: AbstractDocument) -> AbstractNode<ScriptView> {
-        let cx = self.get_cx();
+        DocumentFragment::new(abstract_self)
-        let fragment = @DocumentFragment::new(abstract_self);
-        unsafe { Node::as_abstract_node(cx, fragment) }
     }
 
     pub fn CreateTextNode(&self, abstract_self: AbstractDocument, data: &DOMString) -> AbstractNode<ScriptView> {
-        let cx = self.get_cx();
+        Text::new(null_str_as_empty(data), abstract_self)
-        let text = @Text::new(null_str_as_empty(data), abstract_self);
-        unsafe { Node::as_abstract_node(cx, text) }
     }
 
     pub fn CreateComment(&self, abstract_self: AbstractDocument, data: &DOMString) -> AbstractNode<ScriptView> {
-        let cx = self.get_cx();
+        Comment::new(null_str_as_word_null(data), abstract_self)
-        let comment = @Comment::new(null_str_as_word_null(data), abstract_self);
-        unsafe { Node::as_abstract_node(cx, comment) }
     }
 
     pub fn Title(&self, _: AbstractDocument) -> DOMString {

src/components/script/dom/documentfragment.rs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::codegen::DocumentFragmentBinding;
 use dom::bindings::utils::Fallible;
 use dom::document::AbstractDocument;
 use dom::node::{ScriptView, Node, DocumentFragmentNodeTypeId};
@@ -14,15 +15,20 @@ pub struct DocumentFragment {
 
 impl DocumentFragment {
     /// Creates a new DocumentFragment.
-    pub fn new(document: AbstractDocument) -> DocumentFragment {
+    pub fn new_inherited(document: AbstractDocument) -> DocumentFragment {
         DocumentFragment {
             node: Node::new(DocumentFragmentNodeTypeId, document),
         }
     }
 
-    pub fn Constructor(owner: @mut Window) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn new(document: AbstractDocument) -> AbstractNode<ScriptView> {
-        let cx = owner.get_cx();
+        let node = DocumentFragment::new_inherited(document);
-        let fragment = @DocumentFragment::new(owner.Document());
+        Node::reflect_node(@mut node, document, DocumentFragmentBinding::Wrap)
-        Ok(unsafe { Node::as_abstract_node(cx, fragment) })
+    }
+}
+
+impl DocumentFragment {
+    pub fn Constructor(owner: @mut Window) -> Fallible<AbstractNode<ScriptView>> {
+        Ok(DocumentFragment::new(owner.Document()))
     }
 }

src/components/script/dom/documenttype.rs

@@ -2,9 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::codegen::DocumentTypeBinding;
 use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
-use dom::node::{ScriptView, Node, DoctypeNodeTypeId};
+use dom::node::{AbstractNode, ScriptView, Node, DoctypeNodeTypeId};
 
 /// The `DOCTYPE` tag.
 pub struct DocumentType {
@@ -16,12 +17,11 @@ pub struct DocumentType {
 }
 
 impl DocumentType {
-    /// Creates a new `DOCTYPE` tag.
+    pub fn new_inherited(name: ~str,
-    pub fn new(name: ~str,
+                         public_id: Option<~str>,
-               public_id: Option<~str>,
+                         system_id: Option<~str>,
-               system_id: Option<~str>,
+                         force_quirks: bool,
-               force_quirks: bool,
+                         document: AbstractDocument)
-               document: AbstractDocument)
             -> DocumentType {
         DocumentType {
             node: Node::new(DoctypeNodeTypeId, document),
@@ -32,6 +32,21 @@ impl DocumentType {
         }
     }
 
+    pub fn new(name: ~str,
+               public_id: Option<~str>,
+               system_id: Option<~str>,
+               force_quirks: bool,
+               document: AbstractDocument) -> AbstractNode<ScriptView> {
+        let documenttype = DocumentType::new_inherited(name,
+                                                       public_id,
+                                                       system_id,
+                                                       force_quirks,
+                                                       document);
+        Node::reflect_node(@mut documenttype, document, DocumentTypeBinding::Wrap)
+    }
+}
+
+impl DocumentType {
     pub fn Name(&self) -> DOMString {
         Some(self.name.clone())
     }

src/components/script/dom/node.rs

@@ -4,7 +4,6 @@
 
 //! The core DOM types. Defines the basic DOM hierarchy as well as all the HTML elements.
 
-use dom::bindings::node;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::utils::{DOMString, null_str_as_empty};
 use dom::bindings::utils::{ErrorResult, Fallible, NotFound, HierarchyRequest};
@@ -498,15 +497,6 @@ impl<View> Node<View> {
 }
 
 impl Node<ScriptView> {
-    pub unsafe fn as_abstract_node<N>(cx: *JSContext, node: @N) -> AbstractNode<ScriptView> {
-        // This surrenders memory management of the node!
-        let mut node = AbstractNode {
-            obj: transmute(node),
-        };
-        node::create(cx, &mut node);
-        node
-    }
-
     pub fn reflect_node<N: Reflectable>
             (node:      @mut N,
              document:  AbstractDocument,

src/components/script/dom/text.rs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::codegen::TextBinding;
 use dom::bindings::utils::{DOMString, Fallible, null_str_as_empty};
 use dom::characterdata::CharacterData;
 use dom::document::AbstractDocument;
@@ -14,17 +15,19 @@ pub struct Text {
 }
 
 impl Text {
-    /// Creates a new HTML text node.
+    pub fn new_inherited(text: ~str, document: AbstractDocument) -> Text {
-    pub fn new(text: ~str, document: AbstractDocument) -> Text {
         Text {
             element: CharacterData::new(TextNodeTypeId, text, document)
         }
     }
 
+    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+        let node = Text::new_inherited(text, document);
+        Node::reflect_node(@mut node, document, TextBinding::Wrap)
+    }
+
     pub fn Constructor(owner: @mut Window, text: &DOMString) -> Fallible<AbstractNode<ScriptView>> {
-        let cx = owner.get_cx();
+        Ok(Text::new(null_str_as_empty(text), owner.Document()))
-        let text = @Text::new(null_str_as_empty(text), owner.Document());
-        Ok(unsafe { Node::as_abstract_node(cx, text) })
     }
 
     pub fn SplitText(&self, _offset: u32) -> Fallible<AbstractNode<ScriptView>> {

src/components/script/html/hubbub_html_parser.rs

@@ -8,7 +8,7 @@ use dom::htmlelement::HTMLElement;
 use dom::htmlheadingelement::{Heading1, Heading2, Heading3, Heading4, Heading5, Heading6};
 use dom::htmliframeelement::IFrameSize;
 use dom::htmlformelement::HTMLFormElement;
-use dom::node::{AbstractNode, ElementNodeTypeId, Node, ScriptView};
+use dom::node::{AbstractNode, ElementNodeTypeId, ScriptView};
 use dom::types::*;
 use html::cssparse::{InlineProvenance, StylesheetProvenance, UrlProvenance, spawn_css_parser};
 use js::jsapi::JSContext;
@@ -314,10 +314,8 @@ pub fn parse_html(cx: *JSContext,
     parser.set_tree_handler(~hubbub::TreeHandler {
         create_comment: |data: ~str| {
             debug!("create comment");
-            let comment = @Comment::new(data, document);
+            let comment = Comment::new(data, document);
-            unsafe {
+            unsafe { comment.to_hubbub_node() }
-                Node::as_abstract_node(cx, comment).to_hubbub_node()
-            }
         },
         create_doctype: |doctype: ~hubbub::Doctype| {
             debug!("create doctype");
@@ -325,13 +323,13 @@ pub fn parse_html(cx: *JSContext,
                                 public_id: public_id,
                                 system_id: system_id,
                                 force_quirks: force_quirks } = doctype;
-            let node = @DocumentType::new(name,
+            let node = DocumentType::new(name,
-                                          public_id,
+                                         public_id,
-                                          system_id,
+                                         system_id,
-                                          force_quirks,
+                                         force_quirks,
-                                          document);
+                                         document);
             unsafe {
-                Node::as_abstract_node(cx, node).to_hubbub_node()
+                node.to_hubbub_node()
             }
         },
         create_element: |tag: ~hubbub::Tag| {
@@ -415,8 +413,8 @@ pub fn parse_html(cx: *JSContext,
         },
         create_text: |data: ~str| {
             debug!("create text");
-            let text = @Text::new(data, document);
+            let text = Text::new(data, document);
-            unsafe { Node::as_abstract_node(cx, text).to_hubbub_node() }
+            unsafe { text.to_hubbub_node() }
         },
         ref_node: |_| {},
         unref_node: |_| {},