Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 13:40:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source
This commit is contained in:
bors-servo 2013-11-05 09:34:25 -08:00
commit d00736a9c0
9 changed files with 68 additions and 154 deletions
Download patch file Download diff file Expand all files Collapse all files

92
src/components/script/dom/bindings/node.rs
View file

@ -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::{DoctypeNodeTypeId, DocumentFragmentNodeTypeId, ScriptView, DocumentNodeTypeId};
use dom::node::{AbstractNode, ScriptView};
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()

12
src/components/script/dom/bindings/utils.rs
View file

@ -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() {
unsafe { *vp = RUST_OBJECT_TO_JSVAL(obj) };
return 1;
}
unsafe { *vp = RUST_OBJECT_TO_JSVAL(node::create(cx, self)) };
return 1;
assert!(obj.is_not_null());
unsafe { *vp = RUST_OBJECT_TO_JSVAL(obj) };
return true as i32;
}
}

14
src/components/script/dom/comment.rs
View file

@ -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(text: ~str, document: AbstractDocument) -> Comment {
pub fn new_inherited(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);
let cx = owner.get_cx();
let comment = @Comment::new(s, owner.Document());
Ok(unsafe { Node::as_abstract_node(cx, comment) })
Ok(Comment::new(null_str_as_empty(data), owner.Document()))
}
}

12
src/components/script/dom/document.rs
View file

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

16
src/components/script/dom/documentfragment.rs
View file

@ -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>> {
let cx = owner.get_cx();
let fragment = @DocumentFragment::new(owner.Document());
Ok(unsafe { Node::as_abstract_node(cx, fragment) })
pub fn new(document: AbstractDocument) -> AbstractNode<ScriptView> {
let node = DocumentFragment::new_inherited(document);
Node::reflect_node(@mut node, document, DocumentFragmentBinding::Wrap)
}
}
impl DocumentFragment {
pub fn Constructor(owner: @mut Window) -> Fallible<AbstractNode<ScriptView>> {
Ok(DocumentFragment::new(owner.Document()))
}
}

29
src/components/script/dom/documenttype.rs
View file

@ -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(name: ~str,
public_id: Option<~str>,
system_id: Option<~str>,
force_quirks: bool,
document: AbstractDocument)
pub fn new_inherited(name: ~str,
public_id: Option<~str>,
system_id: Option<~str>,
force_quirks: bool,
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())
}

10
src/components/script/dom/node.rs
View file

@ -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,

13
src/components/script/dom/text.rs
View file

@ -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(text: ~str, document: AbstractDocument) -> Text {
pub fn new_inherited(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();
let text = @Text::new(null_str_as_empty(text), owner.Document());
Ok(unsafe { Node::as_abstract_node(cx, text) })
Ok(Text::new(null_str_as_empty(text), owner.Document()))
}
pub fn SplitText(&self, _offset: u32) -> Fallible<AbstractNode<ScriptView>> {

24
src/components/script/html/hubbub_html_parser.rs
View file

@ -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);
unsafe {
Node::as_abstract_node(cx, comment).to_hubbub_node()
}
let comment = Comment::new(data, document);
unsafe { 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,
public_id,
system_id,
force_quirks,
document);
let node = DocumentType::new(name,
public_id,
system_id,
force_quirks,
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);
unsafe { Node::as_abstract_node(cx, text).to_hubbub_node() }
let text = Text::new(data, document);
unsafe { text.to_hubbub_node() }
},
ref_node: |_| {},
unref_node: |_| {},