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

Remove all root collections.

Browse source
This commit is contained in:
Josh Matthews 2014-04-17 23:26:42 -04:00
parent aaf0a61194
commit 7b3e6d1f21
35 changed files with 329 additions and 475 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/components/script/dom/attr.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::AttrBinding; use dom::bindings::codegen::BindingDeclarations::AttrBinding;
use dom::bindings::codegen::InheritTypes::NodeCast; use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::js::{JS, JSRef, Temporary, RootCollection}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::Element; use dom::element::Element;
use dom::node::Node; use dom::node::Node;
@ -65,8 +65,7 @@ impl Attr {
} }
pub fn set_value(&mut self, set_type: AttrSettingType, value: DOMString) { pub fn set_value(&mut self, set_type: AttrSettingType, value: DOMString) {
let roots = RootCollection::new(); let owner = self.owner.root();
let owner = self.owner.root(&roots);
let node: &JSRef<Node> = NodeCast::from_ref(&*owner); let node: &JSRef<Node> = NodeCast::from_ref(&*owner);
let namespace_is_null = self.namespace == namespace::Null; let namespace_is_null = self.namespace == namespace::Null;

8
src/components/script/dom/attrlist.rs
View file

@ -4,7 +4,7 @@
use dom::attr::Attr; use dom::attr::Attr;
use dom::bindings::codegen::BindingDeclarations::AttrListBinding; use dom::bindings::codegen::BindingDeclarations::AttrListBinding;
use dom::bindings::js::{JS, JSRef, Temporary, RootCollection}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::Element; use dom::element::Element;
use dom::window::Window; use dom::window::Window;
@ -39,13 +39,11 @@ pub trait AttrListMethods {
impl<'a> AttrListMethods for JSRef<'a, AttrList> { impl<'a> AttrListMethods for JSRef<'a, AttrList> {
fn Length(&self) -> u32 { fn Length(&self) -> u32 {
let roots = RootCollection::new(); self.owner.root().attrs.len() as u32
self.owner.root(&roots).attrs.len() as u32
} }
fn Item(&self, index: u32) -> Option<Temporary<Attr>> { fn Item(&self, index: u32) -> Option<Temporary<Attr>> {
let roots = RootCollection::new(); self.owner.root().attrs.as_slice().get(index as uint).map(|x| Temporary::new(x.clone()))
self.owner.root(&roots).attrs.as_slice().get(index as uint).map(|x| Temporary::new(x.clone()))
} }
fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<Temporary<Attr>> { fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<Temporary<Attr>> {

38
src/components/script/dom/bindings/codegen/CodegenRust.py
View file

@ -903,10 +903,10 @@ def instantiateJSToNativeConversionTemplate(templateTuple, replacements,
if type and 'JS<' in type: if type and 'JS<' in type:
if dealWithOptional or 'Option<' in type: if dealWithOptional or 'Option<' in type:
rootBody = """let ${simpleDeclName} = ${declName}.as_ref().map(|inner| { rootBody = """let ${simpleDeclName} = ${declName}.as_ref().map(|inner| {
inner.root(&roots) //second root code inner.root() //second root code
});""" });"""
else: else:
rootBody = "let ${simpleDeclName} = ${declName}.root(&roots); //third root code" rootBody = "let ${simpleDeclName} = ${declName}.root(); //third root code"
result.append(CGGeneric(string.Template(rootBody).substitute(replacements))) result.append(CGGeneric(string.Template(rootBody).substitute(replacements)))
result.append(CGGeneric("")) result.append(CGGeneric(""))
@ -1799,7 +1799,7 @@ class CGAbstractMethod(CGThing):
def _returnType(self): def _returnType(self):
return (" -> %s" % self.returnType) if self.returnType != "void" else "" return (" -> %s" % self.returnType) if self.returnType != "void" else ""
def _unsafe_open(self): def _unsafe_open(self):
return "\n unsafe {\n let roots = RootCollection::new();\n" if self.unsafe else "" return "\n unsafe {\n" if self.unsafe else ""
def _unsafe_close(self): def _unsafe_close(self):
return "\n }\n" if self.unsafe else "" return "\n }\n" if self.unsafe else ""
@ -2247,7 +2247,7 @@ class CGCallGenerator(CGThing):
self.cgRoot.append(CGGeneric("result = result_fallible.unwrap();")) self.cgRoot.append(CGGeneric("result = result_fallible.unwrap();"))
if typeRetValNeedsRooting(returnType): if typeRetValNeedsRooting(returnType):
self.cgRoot.append(CGGeneric("let result = result.root(&roots);")) self.cgRoot.append(CGGeneric("let result = result.root();"))
def define(self): def define(self):
return self.cgRoot.define() return self.cgRoot.define()
@ -2498,7 +2498,7 @@ class CGSpecializedMethod(CGAbstractExternMethod):
self.descriptor, self.method), self.descriptor, self.method),
pre=extraPre + pre=extraPre +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n").define() " let mut this = this.root();\n").define()
class CGGenericGetter(CGAbstractBindingMethod): class CGGenericGetter(CGAbstractBindingMethod):
""" """
@ -2552,7 +2552,7 @@ class CGSpecializedGetter(CGAbstractExternMethod):
self.descriptor, self.attr)), self.descriptor, self.attr)),
pre=extraPre + pre=extraPre +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n").define() " let mut this = this.root();\n").define()
class CGGenericSetter(CGAbstractBindingMethod): class CGGenericSetter(CGAbstractBindingMethod):
""" """
@ -2606,7 +2606,7 @@ class CGSpecializedSetter(CGAbstractExternMethod):
self.descriptor, self.attr)), self.descriptor, self.attr)),
pre=extraPre + pre=extraPre +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n").define() " let mut this = this.root();\n").define()
class CGMemberJITInfo(CGThing): class CGMemberJITInfo(CGThing):
@ -3531,7 +3531,7 @@ class CGDOMJSProxyHandler_getOwnPropertyDescriptor(CGAbstractExternMethod):
" let index = index.unwrap();\n" + " let index = index.unwrap();\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define() + "\n" + CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define() + "\n" +
"}\n") "}\n")
@ -3578,7 +3578,7 @@ class CGDOMJSProxyHandler_getOwnPropertyDescriptor(CGAbstractExternMethod):
" let name = Some(jsid_to_str(cx, id));\n" + " let name = Some(jsid_to_str(cx, id));\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyNamedGetter(self.descriptor, templateValues)).define() + "\n" + CGIndenter(CGProxyNamedGetter(self.descriptor, templateValues)).define() + "\n" +
"}\n") "}\n")
else: else:
@ -3623,7 +3623,7 @@ class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
" let index = index.unwrap();\n" + " let index = index.unwrap();\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyIndexedSetter(self.descriptor)).define() + CGIndenter(CGProxyIndexedSetter(self.descriptor)).define() +
" return 1;\n" + " return 1;\n" +
"}\n") "}\n")
@ -3641,7 +3641,7 @@ class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
" let name = Some(jsid_to_str(cx, id));\n" + " let name = Some(jsid_to_str(cx, id));\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyNamedSetter(self.descriptor)).define() + "\n" + CGIndenter(CGProxyNamedSetter(self.descriptor)).define() + "\n" +
"}\n") "}\n")
elif self.descriptor.operations['NamedGetter']: elif self.descriptor.operations['NamedGetter']:
@ -3649,7 +3649,7 @@ class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
" let name = Some(jsid_to_str(cx, id));\n" + " let name = Some(jsid_to_str(cx, id));\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyNamedGetter(self.descriptor)).define() + CGIndenter(CGProxyNamedGetter(self.descriptor)).define() +
" if (found) {\n" " if (found) {\n"
" return 0;\n" + " return 0;\n" +
@ -3676,7 +3676,7 @@ class CGDOMJSProxyHandler_hasOwn(CGAbstractExternMethod):
" let index = index.unwrap();\n" + " let index = index.unwrap();\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyIndexedGetter(self.descriptor)).define() + "\n" + CGIndenter(CGProxyIndexedGetter(self.descriptor)).define() + "\n" +
" *bp = found as JSBool;\n" + " *bp = found as JSBool;\n" +
" return 1;\n" + " return 1;\n" +
@ -3690,7 +3690,7 @@ class CGDOMJSProxyHandler_hasOwn(CGAbstractExternMethod):
" let name = Some(jsid_to_str(cx, id));\n" + " let name = Some(jsid_to_str(cx, id));\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyNamedGetter(self.descriptor)).define() + "\n" + CGIndenter(CGProxyNamedGetter(self.descriptor)).define() + "\n" +
" *bp = found as JSBool;\n" " *bp = found as JSBool;\n"
" return 1;\n" " return 1;\n"
@ -3744,7 +3744,7 @@ if expando.is_not_null() {
" let index = index.unwrap();\n" + " let index = index.unwrap();\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define()) CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define())
getIndexedOrExpando += """ getIndexedOrExpando += """
// Even if we don't have this index, we don't forward the // Even if we don't have this index, we don't forward the
@ -3762,7 +3762,7 @@ if expando.is_not_null() {
" let name = Some(jsid_to_str(cx, id));\n" + " let name = Some(jsid_to_str(cx, id));\n" +
" let this = UnwrapProxy(proxy);\n" + " let this = UnwrapProxy(proxy);\n" +
" let this = JS::from_raw(this);\n" + " let this = JS::from_raw(this);\n" +
" let mut this = this.root(&roots);\n" + " let mut this = this.root();\n" +
CGIndenter(CGProxyNamedGetter(self.descriptor, templateValues)).define() + CGIndenter(CGProxyNamedGetter(self.descriptor, templateValues)).define() +
"}\n") % (self.descriptor.concreteType) "}\n") % (self.descriptor.concreteType)
else: else:
@ -3879,9 +3879,8 @@ class CGClassConstructHook(CGAbstractExternMethod):
def generate_code(self): def generate_code(self):
preamble = """ preamble = """
let roots = RootCollection::new();
let global = global_object_for_js_object(JS_CALLEE(cx, &*vp).to_object()); let global = global_object_for_js_object(JS_CALLEE(cx, &*vp).to_object());
let global = global.root(&roots); let global = global.root();
let obj = global.reflector().get_jsobject(); let obj = global.reflector().get_jsobject();
""" """
nativeName = MakeNativeName(self._ctor.identifier.name) nativeName = MakeNativeName(self._ctor.identifier.name)
@ -4123,7 +4122,6 @@ class CGDictionary(CGThing):
return string.Template( return string.Template(
"impl ${selfName} {\n" "impl ${selfName} {\n"
" pub fn new(cx: *JSContext, val: JSVal) -> Result<${selfName}, ()> {\n" " pub fn new(cx: *JSContext, val: JSVal) -> Result<${selfName}, ()> {\n"
" let roots = RootCollection::new();\n" # XXXjdm need to root dict members outside of Init
" let object = if val.is_null_or_undefined() {\n" " let object = if val.is_null_or_undefined() {\n"
" ptr::null()\n" " ptr::null()\n"
" } else if val.is_object() {\n" " } else if val.is_object() {\n"
@ -4323,7 +4321,7 @@ class CGBindingRoot(CGThing):
'js::glue::{RUST_JS_NumberValue, RUST_JSID_IS_STRING}', 'js::glue::{RUST_JS_NumberValue, RUST_JSID_IS_STRING}',
'dom::types::*', 'dom::types::*',
'dom::bindings', 'dom::bindings',
'dom::bindings::js::{JS, JSRef, RootCollection, RootedReference, Temporary, OptionalRootable}', 'dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalRootable}',
'dom::bindings::utils::{CreateDOMGlobal, CreateInterfaceObjects2}', 'dom::bindings::utils::{CreateDOMGlobal, CreateInterfaceObjects2}',
'dom::bindings::utils::{ConstantSpec, cx_for_dom_object, Default}', 'dom::bindings::utils::{ConstantSpec, cx_for_dom_object, Default}',
'dom::bindings::utils::{dom_object_slot, DOM_OBJECT_SLOT, DOMClass}', 'dom::bindings::utils::{dom_object_slot, DOM_OBJECT_SLOT, DOMClass}',

29
src/components/script/dom/bindings/js.rs
View file

@ -54,7 +54,7 @@ impl<T: Reflectable> Temporary<T> {
} }
/// Root this unrooted value. /// Root this unrooted value.
pub fn root<'a, 'b>(self, _collection: &'a RootCollection) -> Root<'a, 'b, T> { pub fn root<'a, 'b>(self) -> Root<'a, 'b, T> {
local_data::get(StackRoots, |opt| { local_data::get(StackRoots, |opt| {
let collection = opt.unwrap(); let collection = opt.unwrap();
unsafe { unsafe {
@ -119,8 +119,13 @@ impl<T: Reflectable> JS<T> {
} }
/// Root this JS-owned value to prevent its collection as garbage. /// Root this JS-owned value to prevent its collection as garbage.
pub fn root<'a, 'b>(&self, collection: &'a RootCollection) -> Root<'a, 'b, T> { pub fn root<'a, 'b>(&self) -> Root<'a, 'b, T> {
collection.new_root(self) local_data::get(StackRoots, |opt| {
let collection = opt.unwrap();
unsafe {
(**collection).new_root(self)
}
})
} }
} }
@ -214,32 +219,32 @@ impl<T: Assignable<U>, U: Reflectable> OptionalAssignable<T> for Option<JS<U>> {
} }
pub trait OptionalRootable<T> { pub trait OptionalRootable<T> {
fn root<'a, 'b>(self, roots: &'a RootCollection) -> Option<Root<'a, 'b, T>>; fn root<'a, 'b>(self) -> Option<Root<'a, 'b, T>>;
} }
impl<T: Reflectable> OptionalRootable<T> for Option<Temporary<T>> { impl<T: Reflectable> OptionalRootable<T> for Option<Temporary<T>> {
fn root<'a, 'b>(self, roots: &'a RootCollection) -> Option<Root<'a, 'b, T>> { fn root<'a, 'b>(self) -> Option<Root<'a, 'b, T>> {
self.map(|inner| inner.root(roots)) self.map(|inner| inner.root())
} }
} }
pub trait OptionalRootedRootable<T> { pub trait OptionalRootedRootable<T> {
fn root<'a, 'b>(&self, roots: &'a RootCollection) -> Option<Root<'a, 'b, T>>; fn root<'a, 'b>(&self) -> Option<Root<'a, 'b, T>>;
} }
impl<T: Reflectable> OptionalRootedRootable<T> for Option<JS<T>> { impl<T: Reflectable> OptionalRootedRootable<T> for Option<JS<T>> {
fn root<'a, 'b>(&self, roots: &'a RootCollection) -> Option<Root<'a, 'b, T>> { fn root<'a, 'b>(&self) -> Option<Root<'a, 'b, T>> {
self.as_ref().map(|inner| inner.root(roots)) self.as_ref().map(|inner| inner.root())
} }
} }
pub trait ResultRootable<T,U> { pub trait ResultRootable<T,U> {
fn root<'a, 'b>(self, roots: &'a RootCollection) -> Result<Root<'a, 'b, T>, U>; fn root<'a, 'b>(self) -> Result<Root<'a, 'b, T>, U>;
} }
impl<T: Reflectable, U> ResultRootable<T, U> for Result<Temporary<T>, U> { impl<T: Reflectable, U> ResultRootable<T, U> for Result<Temporary<T>, U> {
fn root<'a, 'b>(self, roots: &'a RootCollection) -> Result<Root<'a, 'b, T>, U> { fn root<'a, 'b>(self) -> Result<Root<'a, 'b, T>, U> {
self.map(|inner| inner.root(roots)) self.map(|inner| inner.root())
} }
} }

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::PrototypeList; use dom::bindings::codegen::PrototypeList;
use dom::bindings::codegen::PrototypeList::MAX_PROTO_CHAIN_LENGTH; use dom::bindings::codegen::PrototypeList::MAX_PROTO_CHAIN_LENGTH;
use dom::bindings::conversions::{FromJSValConvertible, IDLInterface}; use dom::bindings::conversions::{FromJSValConvertible, IDLInterface};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, Root}; use dom::bindings::js::{JS, JSRef, Temporary, Root};
use dom::bindings::trace::Untraceable; use dom::bindings::trace::Untraceable;
use dom::browsercontext; use dom::browsercontext;
use dom::window; use dom::window;
@ -606,7 +606,6 @@ pub extern fn wrap_for_same_compartment(cx: *JSContext, obj: *JSObject) -> *JSOb
pub extern fn outerize_global(_cx: *JSContext, obj: JSHandleObject) -> *JSObject { pub extern fn outerize_global(_cx: *JSContext, obj: JSHandleObject) -> *JSObject {
unsafe { unsafe {
let roots = RootCollection::new();
debug!("outerizing"); debug!("outerizing");
let obj = *obj.unnamed; let obj = *obj.unnamed;
let win: Root<window::Window> = let win: Root<window::Window> =
@ -614,7 +613,7 @@ pub extern fn outerize_global(_cx: *JSContext, obj: JSHandleObject) -> *JSObject
IDLInterface::get_prototype_id(None::<window::Window>), IDLInterface::get_prototype_id(None::<window::Window>),
IDLInterface::get_prototype_depth(None::<window::Window>)) IDLInterface::get_prototype_depth(None::<window::Window>))
.unwrap() .unwrap()
.root(&roots); .root();
win.deref().browser_context.get_ref().window_proxy() win.deref().browser_context.get_ref().window_proxy()
} }
} }
@ -631,8 +630,7 @@ pub fn global_object_for_js_object(obj: *JSObject) -> JS<window::Window> {
} }
fn cx_for_dom_reflector(obj: *JSObject) -> *JSContext { fn cx_for_dom_reflector(obj: *JSObject) -> *JSContext {
let roots = RootCollection::new(); let win = global_object_for_js_object(obj).root();
let win = global_object_for_js_object(obj).root(&roots);
let js_info = win.get().page().js_info(); let js_info = win.get().page().js_info();
match *js_info { match *js_info {
Some(ref info) => info.js_context.deref().deref().ptr, Some(ref info) => info.js_context.deref().deref().ptr,

5
src/components/script/dom/blob.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::codegen::BindingDeclarations::BlobBinding; use dom::bindings::codegen::BindingDeclarations::BlobBinding;
@ -51,8 +51,7 @@ impl<'a> BlobMethods for JSRef<'a, Blob> {
} }
fn Slice(&self, _start: Option<i64>, _end: Option<i64>, _contentType: Option<DOMString>) -> Temporary<Blob> { fn Slice(&self, _start: Option<i64>, _end: Option<i64>, _contentType: Option<DOMString>) -> Temporary<Blob> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
Blob::new(&window.root_ref()) Blob::new(&window.root_ref())
} }

8
src/components/script/dom/browsercontext.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::js::{JS, JSRef, Temporary, RootCollection}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::trace::Traceable; use dom::bindings::trace::Traceable;
use dom::bindings::utils::Reflectable; use dom::bindings::utils::Reflectable;
use dom::document::Document; use dom::document::Document;
@ -37,8 +37,7 @@ impl BrowserContext {
} }
pub fn active_window(&self) -> Temporary<Window> { pub fn active_window(&self) -> Temporary<Window> {
let roots = RootCollection::new(); let doc = self.active_document().root();
let doc = self.active_document().root(&roots);
Temporary::new(doc.deref().window.clone()) Temporary::new(doc.deref().window.clone())
} }
@ -48,8 +47,7 @@ impl BrowserContext {
} }
pub fn create_window_proxy(&self) -> *JSObject { pub fn create_window_proxy(&self) -> *JSObject {
let roots = RootCollection::new(); let win = self.active_window().root();
let win = self.active_window().root(&roots);
let page = win.get().page(); let page = win.get().page();
let js_info = page.js_info(); let js_info = page.js_info();

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::InheritTypes::CommentDerived; use dom::bindings::codegen::InheritTypes::CommentDerived;
use dom::bindings::codegen::BindingDeclarations::CommentBinding; use dom::bindings::codegen::BindingDeclarations::CommentBinding;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::characterdata::CharacterData; use dom::characterdata::CharacterData;
use dom::document::Document; use dom::document::Document;
@ -41,8 +41,7 @@ impl Comment {
} }
pub fn Constructor(owner: &JSRef<Window>, data: DOMString) -> Fallible<Temporary<Comment>> { pub fn Constructor(owner: &JSRef<Window>, data: DOMString) -> Fallible<Temporary<Comment>> {
let roots = RootCollection::new(); let document = owner.Document().root();
let document = owner.Document().root(&roots);
Ok(Comment::new(data, &*document)) Ok(Comment::new(data, &*document))
} }
} }

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

@ -6,7 +6,7 @@ use dom::bindings::codegen::InheritTypes::{DocumentDerived, EventCast, HTMLEleme
use dom::bindings::codegen::InheritTypes::{HTMLHeadElementCast, TextCast, ElementCast}; use dom::bindings::codegen::InheritTypes::{HTMLHeadElementCast, TextCast, ElementCast};
use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, HTMLHtmlElementCast, NodeCast}; use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, HTMLHtmlElementCast, NodeCast};
use dom::bindings::codegen::BindingDeclarations::DocumentBinding; use dom::bindings::codegen::BindingDeclarations::DocumentBinding;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, OptionalAssignable}; use dom::bindings::js::{JS, JSRef, Temporary, OptionalAssignable};
use dom::bindings::js::OptionalRootable; use dom::bindings::js::OptionalRootable;
use dom::bindings::trace::Untraceable; use dom::bindings::trace::Untraceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -110,13 +110,11 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
} }
fn damage_and_reflow(&self, damage: DocumentDamageLevel) { fn damage_and_reflow(&self, damage: DocumentDamageLevel) {
let roots = RootCollection::new(); self.window.root().damage_and_reflow(damage);
self.window.root(&roots).damage_and_reflow(damage);
} }
fn wait_until_safe_to_modify_dom(&self) { fn wait_until_safe_to_modify_dom(&self) {
let roots = RootCollection::new(); self.window.root().wait_until_safe_to_modify_dom();
self.window.root(&roots).wait_until_safe_to_modify_dom();
} }
@ -124,13 +122,12 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
fn unregister_named_element(&mut self, fn unregister_named_element(&mut self,
to_unregister: &JSRef<Element>, to_unregister: &JSRef<Element>,
id: DOMString) { id: DOMString) {
let roots = RootCollection::new();
let mut is_empty = false; let mut is_empty = false;
match self.idmap.find_mut(&id) { match self.idmap.find_mut(&id) {
None => {}, None => {},
Some(elements) => { Some(elements) => {
let position = elements.iter() let position = elements.iter()
.map(|elem| elem.root(&roots)) .map(|elem| elem.root())
.position(|element| &*element == to_unregister) .position(|element| &*element == to_unregister)
.expect("This element should be in registered."); .expect("This element should be in registered.");
elements.remove(position); elements.remove(position);
@ -146,7 +143,6 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
fn register_named_element(&mut self, fn register_named_element(&mut self,
element: &JSRef<Element>, element: &JSRef<Element>,
id: DOMString) { id: DOMString) {
let roots = RootCollection::new();
assert!({ assert!({
let node: &JSRef<Node> = NodeCast::from_ref(element); let node: &JSRef<Node> = NodeCast::from_ref(element);
node.is_in_doc() node.is_in_doc()
@ -154,13 +150,13 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
// FIXME https://github.com/mozilla/rust/issues/13195 // FIXME https://github.com/mozilla/rust/issues/13195
// Use mangle() when it exists again. // Use mangle() when it exists again.
let root = self.GetDocumentElement().expect("The element is in the document, so there must be a document element.").root(&roots); let root = self.GetDocumentElement().expect("The element is in the document, so there must be a document element.").root();
match self.idmap.find_mut(&id) { match self.idmap.find_mut(&id) {
Some(elements) => { Some(elements) => {
let new_node: &JSRef<Node> = NodeCast::from_ref(element); let new_node: &JSRef<Node> = NodeCast::from_ref(element);
let mut head : uint = 0u; let mut head : uint = 0u;
let root: &JSRef<Node> = NodeCast::from_ref(&*root); let root: &JSRef<Node> = NodeCast::from_ref(&*root);
for node in root.traverse_preorder(&roots) { for node in root.traverse_preorder() {
let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&node); let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&node);
match elem { match elem {
Some(elem) => { Some(elem) => {
@ -188,9 +184,8 @@ impl Document {
window: &JSRef<Window>, window: &JSRef<Window>,
wrap_fn: extern "Rust" fn(*JSContext, &JSRef<Window>, ~Document) -> JS<Document>) wrap_fn: extern "Rust" fn(*JSContext, &JSRef<Window>, ~Document) -> JS<Document>)
-> Temporary<Document> { -> Temporary<Document> {
let roots = RootCollection::new();
assert!(document.reflector().get_jsobject().is_null()); assert!(document.reflector().get_jsobject().is_null());
let mut raw_doc = reflect_dom_object(document, window, wrap_fn).root(&roots); let mut raw_doc = reflect_dom_object(document, window, wrap_fn).root();
assert!(raw_doc.reflector().get_jsobject().is_not_null()); assert!(raw_doc.reflector().get_jsobject().is_not_null());
let mut doc_alias = raw_doc.clone(); let mut doc_alias = raw_doc.clone();
@ -257,15 +252,14 @@ trait PrivateDocumentHelpers {
impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> { impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
fn createNodeList(&self, callback: |node: &JSRef<Node>| -> bool) -> Temporary<NodeList> { fn createNodeList(&self, callback: |node: &JSRef<Node>| -> bool) -> Temporary<NodeList> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
let mut nodes = vec!(); let mut nodes = vec!();
match self.GetDocumentElement().root(&roots) { match self.GetDocumentElement().root() {
None => {}, None => {},
Some(root) => { Some(root) => {
let root: &JSRef<Node> = NodeCast::from_ref(&*root); let root: &JSRef<Node> = NodeCast::from_ref(&*root);
for child in root.traverse_preorder(&roots) { for child in root.traverse_preorder() {
if callback(&child) { if callback(&child) {
nodes.push(child); nodes.push(child);
} }
@ -277,8 +271,7 @@ impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
} }
fn get_html_element(&self) -> Option<Temporary<HTMLHtmlElement>> { fn get_html_element(&self) -> Option<Temporary<HTMLHtmlElement>> {
let roots = RootCollection::new(); self.GetDocumentElement().root().filtered(|root| {
self.GetDocumentElement().root(&roots).filtered(|root| {
root.node.type_id == ElementNodeTypeId(HTMLHtmlElementTypeId) root.node.type_id == ElementNodeTypeId(HTMLHtmlElementTypeId)
}).map(|elem| { }).map(|elem| {
Temporary::new_rooted(HTMLHtmlElementCast::to_ref(&*elem).unwrap()) Temporary::new_rooted(HTMLHtmlElementCast::to_ref(&*elem).unwrap())
@ -330,8 +323,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://dom.spec.whatwg.org/#dom-document-implementation // http://dom.spec.whatwg.org/#dom-document-implementation
fn Implementation(&mut self) -> Temporary<DOMImplementation> { fn Implementation(&mut self) -> Temporary<DOMImplementation> {
if self.implementation.is_none() { if self.implementation.is_none() {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
self.implementation.assign(Some(DOMImplementation::new(&*window))); self.implementation.assign(Some(DOMImplementation::new(&*window)));
} }
Temporary::new(self.implementation.get_ref().clone()) Temporary::new(self.implementation.get_ref().clone())
@ -384,15 +376,13 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://dom.spec.whatwg.org/#dom-document-getelementsbytagname // http://dom.spec.whatwg.org/#dom-document-getelementsbytagname
fn GetElementsByTagName(&self, tag_name: DOMString) -> Temporary<HTMLCollection> { fn GetElementsByTagName(&self, tag_name: DOMString) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
HTMLCollection::by_tag_name(&*window, NodeCast::from_ref(self), tag_name) HTMLCollection::by_tag_name(&*window, NodeCast::from_ref(self), tag_name)
} }
// http://dom.spec.whatwg.org/#dom-document-getelementsbytagnamens // http://dom.spec.whatwg.org/#dom-document-getelementsbytagnamens
fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>, tag_name: DOMString) -> Temporary<HTMLCollection> { fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>, tag_name: DOMString) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
let namespace = match maybe_ns { let namespace = match maybe_ns {
Some(namespace) => Namespace::from_str(namespace), Some(namespace) => Namespace::from_str(namespace),
@ -403,8 +393,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://dom.spec.whatwg.org/#dom-document-getelementsbyclassname // http://dom.spec.whatwg.org/#dom-document-getelementsbyclassname
fn GetElementsByClassName(&self, classes: DOMString) -> Temporary<HTMLCollection> { fn GetElementsByClassName(&self, classes: DOMString) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
HTMLCollection::by_class_name(&*window, NodeCast::from_ref(self), classes) HTMLCollection::by_class_name(&*window, NodeCast::from_ref(self), classes)
} }
@ -538,8 +527,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://dom.spec.whatwg.org/#dom-document-createevent // http://dom.spec.whatwg.org/#dom-document-createevent
fn CreateEvent(&self, interface: DOMString) -> Fallible<Temporary<Event>> { fn CreateEvent(&self, interface: DOMString) -> Fallible<Temporary<Event>> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
match interface.to_ascii_lower().as_slice() { match interface.to_ascii_lower().as_slice() {
// FIXME: Implement CustomEvent (http://dom.spec.whatwg.org/#customevent) // FIXME: Implement CustomEvent (http://dom.spec.whatwg.org/#customevent)
@ -553,10 +541,9 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://www.whatwg.org/specs/web-apps/current-work/#document.title // http://www.whatwg.org/specs/web-apps/current-work/#document.title
fn Title(&self) -> DOMString { fn Title(&self) -> DOMString {
let mut title = ~""; let mut title = ~"";
let roots = RootCollection::new(); self.GetDocumentElement().root().map(|root| {
self.GetDocumentElement().root(&roots).map(|root| {
let root: &JSRef<Node> = NodeCast::from_ref(&*root); let root: &JSRef<Node> = NodeCast::from_ref(&*root);
root.traverse_preorder(&roots) root.traverse_preorder()
.find(|node| node.type_id() == ElementNodeTypeId(HTMLTitleElementTypeId)) .find(|node| node.type_id() == ElementNodeTypeId(HTMLTitleElementTypeId))
.map(|title_elem| { .map(|title_elem| {
for child in title_elem.children() { for child in title_elem.children() {
@ -574,11 +561,10 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://www.whatwg.org/specs/web-apps/current-work/#document.title // http://www.whatwg.org/specs/web-apps/current-work/#document.title
fn SetTitle(&self, title: DOMString) -> ErrorResult { fn SetTitle(&self, title: DOMString) -> ErrorResult {
let roots = RootCollection::new();
self.GetDocumentElement().root(&roots).map(|root| { self.GetDocumentElement().root().map(|root| {
let root: &JSRef<Node> = NodeCast::from_ref(&*root); let root: &JSRef<Node> = NodeCast::from_ref(&*root);
let mut head_node = root.traverse_preorder(&roots).find(|child| { let mut head_node = root.traverse_preorder().find(|child| {
child.get().type_id == ElementNodeTypeId(HTMLHeadElementTypeId) child.get().type_id == ElementNodeTypeId(HTMLHeadElementTypeId)
}); });
head_node.as_mut().map(|head| { head_node.as_mut().map(|head| {
@ -591,15 +577,15 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
for mut title_child in title_node.children() { for mut title_child in title_node.children() {
assert!(title_node.RemoveChild(&mut title_child).is_ok()); assert!(title_node.RemoveChild(&mut title_child).is_ok());
} }
let mut new_text = self.CreateTextNode(title.clone()).root(&roots); let mut new_text = self.CreateTextNode(title.clone()).root();
assert!(title_node.AppendChild(NodeCast::from_mut_ref(&mut *new_text)).is_ok()); assert!(title_node.AppendChild(NodeCast::from_mut_ref(&mut *new_text)).is_ok());
}, },
None => { None => {
let mut new_title = HTMLTitleElement::new(~"title", self).root(&roots); let mut new_title = HTMLTitleElement::new(~"title", self).root();
let new_title: &mut JSRef<Node> = NodeCast::from_mut_ref(&mut *new_title); let new_title: &mut JSRef<Node> = NodeCast::from_mut_ref(&mut *new_title);
let mut new_text = self.CreateTextNode(title.clone()).root(&roots); let mut new_text = self.CreateTextNode(title.clone()).root();
assert!(new_title.AppendChild(NodeCast::from_mut_ref(&mut *new_text)).is_ok()); assert!(new_title.AppendChild(NodeCast::from_mut_ref(&mut *new_text)).is_ok());
assert!(head.AppendChild(&mut *new_title).is_ok()); assert!(head.AppendChild(&mut *new_title).is_ok());
@ -612,9 +598,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://www.whatwg.org/specs/web-apps/current-work/#dom-document-head // http://www.whatwg.org/specs/web-apps/current-work/#dom-document-head
fn GetHead(&self) -> Option<Temporary<HTMLHeadElement>> { fn GetHead(&self) -> Option<Temporary<HTMLHeadElement>> {
let roots = RootCollection::new();
self.get_html_element().and_then(|root| { self.get_html_element().and_then(|root| {
let root = root.root(&roots); let root = root.root();
let node: &JSRef<Node> = NodeCast::from_ref(&*root); let node: &JSRef<Node> = NodeCast::from_ref(&*root);
node.children().find(|child| { node.children().find(|child| {
child.type_id() == ElementNodeTypeId(HTMLHeadElementTypeId) child.type_id() == ElementNodeTypeId(HTMLHeadElementTypeId)
@ -626,9 +611,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://www.whatwg.org/specs/web-apps/current-work/#dom-document-body // http://www.whatwg.org/specs/web-apps/current-work/#dom-document-body
fn GetBody(&self) -> Option<Temporary<HTMLElement>> { fn GetBody(&self) -> Option<Temporary<HTMLElement>> {
let roots = RootCollection::new();
self.get_html_element().and_then(|root| { self.get_html_element().and_then(|root| {
let root = root.root(&roots); let root = root.root();
let node: &JSRef<Node> = NodeCast::from_ref(&*root); let node: &JSRef<Node> = NodeCast::from_ref(&*root);
node.children().find(|child| { node.children().find(|child| {
match child.type_id() { match child.type_id() {
@ -644,7 +628,6 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://www.whatwg.org/specs/web-apps/current-work/#dom-document-body // http://www.whatwg.org/specs/web-apps/current-work/#dom-document-body
fn SetBody(&self, new_body: Option<JSRef<HTMLElement>>) -> ErrorResult { fn SetBody(&self, new_body: Option<JSRef<HTMLElement>>) -> ErrorResult {
let roots = RootCollection::new();
// Step 1. // Step 1.
match new_body { match new_body {
@ -659,14 +642,14 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
// Step 2. // Step 2.
let mut old_body = self.GetBody().root(&roots); let mut old_body = self.GetBody().root();
//FIXME: covariant lifetime workaround. do not judge. //FIXME: covariant lifetime workaround. do not judge.
if old_body.as_ref().map(|body| body.deref()) == new_body.as_ref().map(|a| &*a) { if old_body.as_ref().map(|body| body.deref()) == new_body.as_ref().map(|a| &*a) {
return Ok(()); return Ok(());
} }
// Step 3. // Step 3.
match self.get_html_element().root(&roots) { match self.get_html_element().root() {
// Step 4. // Step 4.
None => return Err(HierarchyRequest), None => return Err(HierarchyRequest),
Some(ref mut root) => { Some(ref mut root) => {
@ -689,7 +672,6 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://www.whatwg.org/specs/web-apps/current-work/#dom-document-getelementsbyname // http://www.whatwg.org/specs/web-apps/current-work/#dom-document-getelementsbyname
fn GetElementsByName(&self, name: DOMString) -> Temporary<NodeList> { fn GetElementsByName(&self, name: DOMString) -> Temporary<NodeList> {
let roots = RootCollection::new();
self.createNodeList(|node| { self.createNodeList(|node| {
if !node.is_element() { if !node.is_element() {
@ -697,15 +679,14 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap(); let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
element.get_attribute(Null, "name").root(&roots).map_or(false, |mut attr| { element.get_attribute(Null, "name").root().map_or(false, |mut attr| {
attr.value_ref() == name attr.value_ref() == name
}) })
}) })
} }
fn Images(&self) -> Temporary<HTMLCollection> { fn Images(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
// FIXME: https://github.com/mozilla/servo/issues/1847 // FIXME: https://github.com/mozilla/servo/issues/1847
struct ImagesFilter; struct ImagesFilter;
@ -719,8 +700,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
fn Embeds(&self) -> Temporary<HTMLCollection> { fn Embeds(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
// FIXME: https://github.com/mozilla/servo/issues/1847 // FIXME: https://github.com/mozilla/servo/issues/1847
struct EmbedsFilter; struct EmbedsFilter;
@ -739,8 +719,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
fn Links(&self) -> Temporary<HTMLCollection> { fn Links(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
// FIXME: https://github.com/mozilla/servo/issues/1847 // FIXME: https://github.com/mozilla/servo/issues/1847
struct LinksFilter; struct LinksFilter;
@ -755,8 +734,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
fn Forms(&self) -> Temporary<HTMLCollection> { fn Forms(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
// FIXME: https://github.com/mozilla/servo/issues/1847 // FIXME: https://github.com/mozilla/servo/issues/1847
struct FormsFilter; struct FormsFilter;
@ -770,8 +748,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
fn Scripts(&self) -> Temporary<HTMLCollection> { fn Scripts(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
// FIXME: https://github.com/mozilla/servo/issues/1847 // FIXME: https://github.com/mozilla/servo/issues/1847
struct ScriptsFilter; struct ScriptsFilter;
@ -785,8 +762,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
fn Anchors(&self) -> Temporary<HTMLCollection> { fn Anchors(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
// FIXME: https://github.com/mozilla/servo/issues/1847 // FIXME: https://github.com/mozilla/servo/issues/1847
struct AnchorsFilter; struct AnchorsFilter;
@ -800,8 +776,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
fn Applets(&self) -> Temporary<HTMLCollection> { fn Applets(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
// FIXME: This should be return OBJECT elements containing applets. // FIXME: This should be return OBJECT elements containing applets.
struct AppletsFilter; struct AppletsFilter;
@ -815,14 +790,12 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
fn Location(&mut self) -> Temporary<Location> { fn Location(&mut self) -> Temporary<Location> {
let roots = RootCollection::new(); let mut window = self.window.root();
let mut window = self.window.root(&roots);
window.Location() window.Location()
} }
fn Children(&self) -> Temporary<HTMLCollection> { fn Children(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
HTMLCollection::children(&*window, NodeCast::from_ref(self)) HTMLCollection::children(&*window, NodeCast::from_ref(self))
} }
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::InheritTypes::{DocumentFragmentDerived, NodeCast}; use dom::bindings::codegen::InheritTypes::{DocumentFragmentDerived, NodeCast};
use dom::bindings::codegen::BindingDeclarations::DocumentFragmentBinding; use dom::bindings::codegen::BindingDeclarations::DocumentFragmentBinding;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::document::Document; use dom::document::Document;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -40,9 +40,8 @@ impl DocumentFragment {
} }
pub fn Constructor(owner: &JSRef<Window>) -> Fallible<Temporary<DocumentFragment>> { pub fn Constructor(owner: &JSRef<Window>) -> Fallible<Temporary<DocumentFragment>> {
let roots = RootCollection::new();
let document = owner.Document(); let document = owner.Document();
let document = document.root(&roots); let document = document.root();
Ok(DocumentFragment::new(&document.root_ref())) Ok(DocumentFragment::new(&document.root_ref()))
} }
@ -54,8 +53,7 @@ pub trait DocumentFragmentMethods {
impl<'a> DocumentFragmentMethods for JSRef<'a, DocumentFragment> { impl<'a> DocumentFragmentMethods for JSRef<'a, DocumentFragment> {
fn Children(&self) -> Temporary<HTMLCollection> { fn Children(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
HTMLCollection::children(&window.root_ref(), NodeCast::from_ref(self)) HTMLCollection::children(&window.root_ref(), NodeCast::from_ref(self))
} }
} }

31
src/components/script/dom/domimplementation.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::DOMImplementationBinding; use dom::bindings::codegen::BindingDeclarations::DOMImplementationBinding;
use dom::bindings::codegen::InheritTypes::NodeCast; use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, OptionalRootable}; use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object}; use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::bindings::error::{Fallible, InvalidCharacter, NamespaceError}; use dom::bindings::error::{Fallible, InvalidCharacter, NamespaceError};
use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type}; use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type};
@ -60,7 +60,6 @@ pub trait DOMImplementationMethods {
impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> { impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
// http://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype // http://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype
fn CreateDocumentType(&self, qname: DOMString, pubid: DOMString, sysid: DOMString) -> Fallible<Temporary<DocumentType>> { fn CreateDocumentType(&self, qname: DOMString, pubid: DOMString, sysid: DOMString) -> Fallible<Temporary<DocumentType>> {
let roots = RootCollection::new();
match xml_name_type(qname) { match xml_name_type(qname) {
// Step 1. // Step 1.
InvalidXMLName => Err(InvalidCharacter), InvalidXMLName => Err(InvalidCharacter),
@ -68,8 +67,8 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
Name => Err(NamespaceError), Name => Err(NamespaceError),
// Step 3. // Step 3.
QName => { QName => {
let owner = self.owner.root(&roots); let owner = self.owner.root();
let document = owner.deref().Document().root(&roots); let document = owner.deref().Document().root();
Ok(DocumentType::new(qname, Some(pubid), Some(sysid), &*document)) Ok(DocumentType::new(qname, Some(pubid), Some(sysid), &*document))
} }
} }
@ -78,11 +77,10 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
// http://dom.spec.whatwg.org/#dom-domimplementation-createdocument // http://dom.spec.whatwg.org/#dom-domimplementation-createdocument
fn CreateDocument(&self, namespace: Option<DOMString>, qname: DOMString, fn CreateDocument(&self, namespace: Option<DOMString>, qname: DOMString,
mut maybe_doctype: Option<JSRef<DocumentType>>) -> Fallible<Temporary<Document>> { mut maybe_doctype: Option<JSRef<DocumentType>>) -> Fallible<Temporary<Document>> {
let roots = RootCollection::new(); let win = self.owner.root();
let win = self.owner.root(&roots);
// Step 1. // Step 1.
let mut doc = Document::new(&win.root_ref(), None, NonHTMLDocument, None).root(&roots); let mut doc = Document::new(&win.root_ref(), None, NonHTMLDocument, None).root();
// Step 2-3. // Step 2-3.
let mut maybe_elem = if qname.is_empty() { let mut maybe_elem = if qname.is_empty() {
None None
@ -105,7 +103,7 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
} }
// Step 5. // Step 5.
match maybe_elem.root(&roots) { match maybe_elem.root() {
None => (), None => (),
Some(mut elem) => { Some(mut elem) => {
assert!(doc_node.AppendChild(NodeCast::from_mut_ref(&mut *elem)).is_ok()) assert!(doc_node.AppendChild(NodeCast::from_mut_ref(&mut *elem)).is_ok())
@ -122,28 +120,27 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
// http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument // http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
fn CreateHTMLDocument(&self, title: Option<DOMString>) -> Temporary<Document> { fn CreateHTMLDocument(&self, title: Option<DOMString>) -> Temporary<Document> {
let roots = RootCollection::new(); let owner = self.owner.root();
let owner = self.owner.root(&roots);
// Step 1-2. // Step 1-2.
let mut doc = Document::new(&owner.root_ref(), None, HTMLDocument, None).root(&roots); let mut doc = Document::new(&owner.root_ref(), None, HTMLDocument, None).root();
let mut doc_alias = doc.clone(); let mut doc_alias = doc.clone();
let doc_node: &mut JSRef<Node> = NodeCast::from_mut_ref(&mut doc_alias); let doc_node: &mut JSRef<Node> = NodeCast::from_mut_ref(&mut doc_alias);
{ {
// Step 3. // Step 3.
let mut doc_type = DocumentType::new(~"html", None, None, &*doc).root(&roots); let mut doc_type = DocumentType::new(~"html", None, None, &*doc).root();
assert!(doc_node.AppendChild(NodeCast::from_mut_ref(&mut *doc_type)).is_ok()); assert!(doc_node.AppendChild(NodeCast::from_mut_ref(&mut *doc_type)).is_ok());
} }
{ {
// Step 4. // Step 4.
let mut doc_html = NodeCast::from_unrooted(HTMLHtmlElement::new(~"html", &*doc)).root(&roots); let mut doc_html = NodeCast::from_unrooted(HTMLHtmlElement::new(~"html", &*doc)).root();
assert!(doc_node.AppendChild(&mut *doc_html).is_ok()); assert!(doc_node.AppendChild(&mut *doc_html).is_ok());
{ {
// Step 5. // Step 5.
let mut doc_head = NodeCast::from_unrooted(HTMLHeadElement::new(~"head", &*doc)).root(&roots); let mut doc_head = NodeCast::from_unrooted(HTMLHeadElement::new(~"head", &*doc)).root();
assert!(doc_html.AppendChild(&mut *doc_head).is_ok()); assert!(doc_html.AppendChild(&mut *doc_head).is_ok());
// Step 6. // Step 6.
@ -151,18 +148,18 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
None => (), None => (),
Some(title_str) => { Some(title_str) => {
// Step 6.1. // Step 6.1.
let mut doc_title = NodeCast::from_unrooted(HTMLTitleElement::new(~"title", &*doc)).root(&roots); let mut doc_title = NodeCast::from_unrooted(HTMLTitleElement::new(~"title", &*doc)).root();
assert!(doc_head.AppendChild(&mut *doc_title).is_ok()); assert!(doc_head.AppendChild(&mut *doc_title).is_ok());
// Step 6.2. // Step 6.2.
let mut title_text = Text::new(title_str, &*doc).root(&roots); let mut title_text = Text::new(title_str, &*doc).root();
assert!(doc_title.AppendChild(NodeCast::from_mut_ref(&mut *title_text)).is_ok()); assert!(doc_title.AppendChild(NodeCast::from_mut_ref(&mut *title_text)).is_ok());
} }
} }
} }
// Step 7. // Step 7.
let mut doc_body = HTMLBodyElement::new(~"body", &*doc).root(&roots); let mut doc_body = HTMLBodyElement::new(~"body", &*doc).root();
assert!(doc_html.AppendChild(NodeCast::from_mut_ref(&mut *doc_body)).is_ok()); assert!(doc_html.AppendChild(NodeCast::from_mut_ref(&mut *doc_body)).is_ok());
} }

5
src/components/script/dom/domparser.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::DOMParserBinding; use dom::bindings::codegen::BindingDeclarations::DOMParserBinding;
use dom::bindings::codegen::BindingDeclarations::DOMParserBinding::SupportedTypeValues::{Text_html, Text_xml}; use dom::bindings::codegen::BindingDeclarations::DOMParserBinding::SupportedTypeValues::{Text_html, Text_xml};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object}; use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::bindings::error::{Fallible, FailureUnknown}; use dom::bindings::error::{Fallible, FailureUnknown};
use dom::document::{Document, HTMLDocument, NonHTMLDocument}; use dom::document::{Document, HTMLDocument, NonHTMLDocument};
@ -44,8 +44,7 @@ impl<'a> DOMParserMethods for JSRef<'a, DOMParser> {
_s: DOMString, _s: DOMString,
ty: DOMParserBinding::SupportedType) ty: DOMParserBinding::SupportedType)
-> Fallible<Temporary<Document>> { -> Fallible<Temporary<Document>> {
let roots = RootCollection::new(); let owner = self.owner.root();
let owner = self.owner.root(&roots);
match ty { match ty {
Text_html => { Text_html => {
Ok(Document::new(&owner.root_ref(), None, HTMLDocument, Some(~"text/html"))) Ok(Document::new(&owner.root_ref(), None, HTMLDocument, Some(~"text/html")))

85
src/components/script/dom/element.rs
View file

@ -8,7 +8,7 @@ use dom::attr::{Attr, ReplacedAttr, FirstSetAttr, AttrMethods};
use dom::attrlist::AttrList; use dom::attrlist::AttrList;
use dom::bindings::codegen::BindingDeclarations::ElementBinding; use dom::bindings::codegen::BindingDeclarations::ElementBinding;
use dom::bindings::codegen::InheritTypes::{ElementDerived, NodeCast}; use dom::bindings::codegen::InheritTypes::{ElementDerived, NodeCast};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, TemporaryPushable}; use dom::bindings::js::{JS, JSRef, Temporary, TemporaryPushable};
use dom::bindings::js::{OptionalAssignable, OptionalRootable, Root}; use dom::bindings::js::{OptionalAssignable, OptionalRootable, Root};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::bindings::error::{ErrorResult, Fallible, NamespaceError, InvalidCharacter}; use dom::bindings::error::{ErrorResult, Fallible, NamespaceError, InvalidCharacter};
@ -198,10 +198,9 @@ pub trait ElementHelpers {
impl<'a> ElementHelpers for JSRef<'a, Element> { impl<'a> ElementHelpers for JSRef<'a, Element> {
fn html_element_in_html_document(&self) -> bool { fn html_element_in_html_document(&self) -> bool {
let roots = RootCollection::new();
let is_html = self.namespace == namespace::HTML; let is_html = self.namespace == namespace::HTML;
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
is_html && node.owner_doc().root(&roots).is_html_document is_html && node.owner_doc().root().is_html_document
} }
} }
@ -228,13 +227,12 @@ pub trait AttributeHandlers {
impl<'a> AttributeHandlers for JSRef<'a, Element> { impl<'a> AttributeHandlers for JSRef<'a, Element> {
fn get_attribute(&self, namespace: Namespace, name: &str) -> Option<Temporary<Attr>> { fn get_attribute(&self, namespace: Namespace, name: &str) -> Option<Temporary<Attr>> {
let roots = RootCollection::new();
if self.html_element_in_html_document() { if self.html_element_in_html_document() {
self.get().attrs.iter().map(|attr| attr.root(&roots)).find(|attr| { self.get().attrs.iter().map(|attr| attr.root()).find(|attr| {
name.to_ascii_lower() == attr.local_name && attr.namespace == namespace name.to_ascii_lower() == attr.local_name && attr.namespace == namespace
}).map(|x| Temporary::new_rooted(&*x)) }).map(|x| Temporary::new_rooted(&*x))
} else { } else {
self.get().attrs.iter().map(|attr| attr.root(&roots)).find(|attr| { self.get().attrs.iter().map(|attr| attr.root()).find(|attr| {
name == attr.local_name && attr.namespace == namespace name == attr.local_name && attr.namespace == namespace
}).map(|x| Temporary::new_rooted(&*x)) }).map(|x| Temporary::new_rooted(&*x))
} }
@ -275,14 +273,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
fn do_set_attribute(&mut self, local_name: DOMString, value: DOMString, fn do_set_attribute(&mut self, local_name: DOMString, value: DOMString,
name: DOMString, namespace: Namespace, name: DOMString, namespace: Namespace,
prefix: Option<DOMString>, cb: |&JSRef<Attr>| -> bool) { prefix: Option<DOMString>, cb: |&JSRef<Attr>| -> bool) {
let roots = RootCollection::new();
let idx = self.get().attrs.iter() let idx = self.get().attrs.iter()
.map(|attr| attr.root(&roots)) .map(|attr| attr.root())
.position(|attr| cb(&*attr)); .position(|attr| cb(&*attr));
let (idx, set_type) = match idx { let (idx, set_type) = match idx {
Some(idx) => (idx, ReplacedAttr), Some(idx) => (idx, ReplacedAttr),
None => { None => {
let window = window_from_node(self).root(&roots); let window = window_from_node(self).root();
let attr = Attr::new(&*window, local_name.clone(), value.clone(), let attr = Attr::new(&*window, local_name.clone(), value.clone(),
name, namespace.clone(), prefix, self); name, namespace.clone(), prefix, self);
self.get_mut().attrs.push_unrooted(attr); self.get_mut().attrs.push_unrooted(attr);
@ -290,14 +287,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
} }
}; };
self.get_mut().attrs.get(idx).root(&roots).set_value(set_type, value); self.get_mut().attrs.get(idx).root().set_value(set_type, value);
} }
fn remove_attribute(&mut self, namespace: Namespace, name: DOMString) -> ErrorResult { fn remove_attribute(&mut self, namespace: Namespace, name: DOMString) -> ErrorResult {
let roots = RootCollection::new();
let (_, local_name) = get_attribute_parts(name.clone()); let (_, local_name) = get_attribute_parts(name.clone());
let idx = self.get().attrs.iter().map(|attr| attr.root(&roots)).position(|attr| { let idx = self.get().attrs.iter().map(|attr| attr.root()).position(|attr| {
attr.local_name == local_name attr.local_name == local_name
}); });
@ -310,7 +306,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
} }
if namespace == namespace::Null { if namespace == namespace::Null {
let removed_raw_value = self.get().attrs.get(idx).root(&roots).Value(); let removed_raw_value = self.get().attrs.get(idx).root().Value();
vtable_for(NodeCast::from_ref(self)).before_remove_attr(local_name.clone(), removed_raw_value); vtable_for(NodeCast::from_ref(self)).before_remove_attr(local_name.clone(), removed_raw_value);
} }
@ -322,14 +318,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
} }
fn notify_attribute_changed(&self, local_name: DOMString) { fn notify_attribute_changed(&self, local_name: DOMString) {
let roots = RootCollection::new();
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
if node.is_in_doc() { if node.is_in_doc() {
let damage = match local_name.as_slice() { let damage = match local_name.as_slice() {
"style" | "id" | "class" => MatchSelectorsDocumentDamage, "style" | "id" | "class" => MatchSelectorsDocumentDamage,
_ => ContentChangedDocumentDamage _ => ContentChangedDocumentDamage
}; };
let document = node.owner_doc().root(&roots); let document = node.owner_doc().root();
document.deref().damage_and_reflow(damage); document.deref().damage_and_reflow(damage);
} }
} }
@ -349,10 +344,9 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
} }
fn get_string_attribute(&self, name: &str) -> DOMString { fn get_string_attribute(&self, name: &str) -> DOMString {
let roots = RootCollection::new();
match self.get_attribute(Null, name) { match self.get_attribute(Null, name) {
Some(x) => { Some(x) => {
let x = x.root(&roots); let x = x.root();
x.deref().Value() x.deref().Value()
} }
None => ~"" None => ~""
@ -462,7 +456,6 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// http://dom.spec.whatwg.org/#dom-element-attributes // http://dom.spec.whatwg.org/#dom-element-attributes
fn Attributes(&mut self) -> Temporary<AttrList> { fn Attributes(&mut self) -> Temporary<AttrList> {
let roots = RootCollection::new();
match self.attr_list { match self.attr_list {
None => (), None => (),
Some(ref list) => return Temporary::new(list.clone()), Some(ref list) => return Temporary::new(list.clone()),
@ -470,9 +463,9 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
let doc = { let doc = {
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
node.owner_doc() node.owner_doc().root()
}.root(&roots); };
let window = doc.deref().window.root(&roots); let window = doc.deref().window.root();
let list = AttrList::new(&*window, self); let list = AttrList::new(&*window, self);
self.attr_list.assign(Some(list)); self.attr_list.assign(Some(list));
Temporary::new(self.attr_list.get_ref().clone()) Temporary::new(self.attr_list.get_ref().clone())
@ -480,13 +473,12 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// http://dom.spec.whatwg.org/#dom-element-getattribute // http://dom.spec.whatwg.org/#dom-element-getattribute
fn GetAttribute(&self, name: DOMString) -> Option<DOMString> { fn GetAttribute(&self, name: DOMString) -> Option<DOMString> {
let roots = RootCollection::new();
let name = if self.html_element_in_html_document() { let name = if self.html_element_in_html_document() {
name.to_ascii_lower() name.to_ascii_lower()
} else { } else {
name name
}; };
self.get_attribute(Null, name).root(&roots) self.get_attribute(Null, name).root()
.map(|s| s.deref().Value()) .map(|s| s.deref().Value())
} }
@ -494,9 +486,8 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
fn GetAttributeNS(&self, fn GetAttributeNS(&self,
namespace: Option<DOMString>, namespace: Option<DOMString>,
local_name: DOMString) -> Option<DOMString> { local_name: DOMString) -> Option<DOMString> {
let roots = RootCollection::new();
let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace)); let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace));
self.get_attribute(namespace, local_name).root(&roots) self.get_attribute(namespace, local_name).root()
.map(|attr| attr.deref().Value()) .map(|attr| attr.deref().Value())
} }
@ -624,32 +615,28 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
} }
fn GetElementsByTagName(&self, localname: DOMString) -> Temporary<HTMLCollection> { fn GetElementsByTagName(&self, localname: DOMString) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
HTMLCollection::by_tag_name(&*window, NodeCast::from_ref(self), localname) HTMLCollection::by_tag_name(&*window, NodeCast::from_ref(self), localname)
} }
fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>, fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>,
localname: DOMString) -> Temporary<HTMLCollection> { localname: DOMString) -> Temporary<HTMLCollection> {
let roots = RootCollection::new();
let namespace = match maybe_ns { let namespace = match maybe_ns {
Some(namespace) => Namespace::from_str(namespace), Some(namespace) => Namespace::from_str(namespace),
None => Null None => Null
}; };
let window = window_from_node(self).root(&roots); let window = window_from_node(self).root();
HTMLCollection::by_tag_name_ns(&*window, NodeCast::from_ref(self), localname, namespace) HTMLCollection::by_tag_name_ns(&*window, NodeCast::from_ref(self), localname, namespace)
} }
fn GetElementsByClassName(&self, classes: DOMString) -> Temporary<HTMLCollection> { fn GetElementsByClassName(&self, classes: DOMString) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
HTMLCollection::by_class_name(&*window, NodeCast::from_ref(self), classes) HTMLCollection::by_class_name(&*window, NodeCast::from_ref(self), classes)
} }
// http://dev.w3.org/csswg/cssom-view/#dom-element-getclientrects // http://dev.w3.org/csswg/cssom-view/#dom-element-getclientrects
fn GetClientRects(&self) -> Temporary<ClientRectList> { fn GetClientRects(&self) -> Temporary<ClientRectList> {
let roots = RootCollection::new(); let win = window_from_node(self).root();
let win = window_from_node(self).root(&roots);
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
let rects = node.get_content_boxes(); let rects = node.get_content_boxes();
let rects: ~[Root<ClientRect>] = rects.iter().map(|r| { let rects: ~[Root<ClientRect>] = rects.iter().map(|r| {
@ -658,7 +645,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
r.origin.y, r.origin.y,
r.origin.y + r.size.height, r.origin.y + r.size.height,
r.origin.x, r.origin.x,
r.origin.x + r.size.width).root(&roots) r.origin.x + r.size.width).root()
}).collect(); }).collect();
ClientRectList::new(&*win, rects.iter().map(|rect| rect.deref().clone()).collect()) ClientRectList::new(&*win, rects.iter().map(|rect| rect.deref().clone()).collect())
@ -666,8 +653,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// http://dev.w3.org/csswg/cssom-view/#dom-element-getboundingclientrect // http://dev.w3.org/csswg/cssom-view/#dom-element-getboundingclientrect
fn GetBoundingClientRect(&self) -> Temporary<ClientRect> { fn GetBoundingClientRect(&self) -> Temporary<ClientRect> {
let roots = RootCollection::new(); let win = window_from_node(self).root();
let win = window_from_node(self).root(&roots);
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
let rect = node.get_bounding_content_box(); let rect = node.get_bounding_content_box();
ClientRect::new( ClientRect::new(
@ -680,18 +666,15 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
fn GetInnerHTML(&self) -> Fallible<DOMString> { fn GetInnerHTML(&self) -> Fallible<DOMString> {
//XXX TODO: XML case //XXX TODO: XML case
let roots = RootCollection::new(); Ok(serialize(&mut NodeIterator::new(NodeCast::from_ref(self), false, false)))
Ok(serialize(&mut NodeIterator::new(&roots, NodeCast::from_ref(self), false, false)))
} }
fn GetOuterHTML(&self) -> Fallible<DOMString> { fn GetOuterHTML(&self) -> Fallible<DOMString> {
let roots = RootCollection::new(); Ok(serialize(&mut NodeIterator::new(NodeCast::from_ref(self), true, false)))
Ok(serialize(&mut NodeIterator::new(&roots, NodeCast::from_ref(self), true, false)))
} }
fn Children(&self) -> Temporary<HTMLCollection> { fn Children(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
HTMLCollection::children(&*window, NodeCast::from_ref(self)) HTMLCollection::children(&*window, NodeCast::from_ref(self))
} }
} }
@ -716,7 +699,6 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
} }
fn after_set_attr(&mut self, name: DOMString, value: DOMString) { fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
let roots = RootCollection::new();
match self.super_type() { match self.super_type() {
Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()), Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()),
_ => (), _ => (),
@ -724,14 +706,14 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
match name.as_slice() { match name.as_slice() {
"style" => { "style" => {
let doc = document_from_node(self).root(&roots); let doc = document_from_node(self).root();
let base_url = doc.deref().url().clone(); let base_url = doc.deref().url().clone();
self.get_mut().style_attribute = Some(style::parse_style_attribute(value, &base_url)) self.get_mut().style_attribute = Some(style::parse_style_attribute(value, &base_url))
} }
"id" => { "id" => {
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
if node.is_in_doc() { if node.is_in_doc() {
let mut doc = document_from_node(self).root(&roots); let mut doc = document_from_node(self).root();
doc.register_named_element(self, value.clone()); doc.register_named_element(self, value.clone());
} }
} }
@ -742,7 +724,6 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
} }
fn before_remove_attr(&mut self, name: DOMString, value: DOMString) { fn before_remove_attr(&mut self, name: DOMString, value: DOMString) {
let roots = RootCollection::new();
match self.super_type() { match self.super_type() {
Some(ref mut s) => s.before_remove_attr(name.clone(), value.clone()), Some(ref mut s) => s.before_remove_attr(name.clone(), value.clone()),
_ => (), _ => (),
@ -755,7 +736,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
"id" => { "id" => {
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
if node.is_in_doc() { if node.is_in_doc() {
let mut doc = document_from_node(self).root(&roots); let mut doc = document_from_node(self).root();
doc.unregister_named_element(self, value); doc.unregister_named_element(self, value);
} }
} }
@ -766,15 +747,14 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
} }
fn bind_to_tree(&mut self) { fn bind_to_tree(&mut self) {
let roots = RootCollection::new();
match self.super_type() { match self.super_type() {
Some(ref mut s) => s.bind_to_tree(), Some(ref mut s) => s.bind_to_tree(),
_ => (), _ => (),
} }
match self.get_attribute(Null, "id").root(&roots) { match self.get_attribute(Null, "id").root() {
Some(attr) => { Some(attr) => {
let mut doc = document_from_node(self).root(&roots); let mut doc = document_from_node(self).root();
doc.register_named_element(self, attr.deref().Value()); doc.register_named_element(self, attr.deref().Value());
} }
_ => () _ => ()
@ -782,15 +762,14 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
} }
fn unbind_from_tree(&mut self) { fn unbind_from_tree(&mut self) {
let roots = RootCollection::new();
match self.super_type() { match self.super_type() {
Some(ref mut s) => s.unbind_from_tree(), Some(ref mut s) => s.unbind_from_tree(),
_ => (), _ => (),
} }
match self.get_attribute(Null, "id").root(&roots) { match self.get_attribute(Null, "id").root() {
Some(attr) => { Some(attr) => {
let mut doc = document_from_node(self).root(&roots); let mut doc = document_from_node(self).root();
doc.unregister_named_element(self, attr.deref().Value()); doc.unregister_named_element(self, attr.deref().Value());
} }
_ => () _ => ()

5
src/components/script/dom/event.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::EventBinding; use dom::bindings::codegen::BindingDeclarations::EventBinding;
use dom::bindings::codegen::BindingDeclarations::EventBinding::EventConstants; use dom::bindings::codegen::BindingDeclarations::EventBinding::EventConstants;
use dom::bindings::js::{JS, JSRef, Temporary, RootCollection}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::eventtarget::EventTarget; use dom::eventtarget::EventTarget;
@ -89,8 +89,7 @@ impl Event {
pub fn Constructor(global: &JSRef<Window>, pub fn Constructor(global: &JSRef<Window>,
type_: DOMString, type_: DOMString,
init: &EventBinding::EventInit) -> Fallible<Temporary<Event>> { init: &EventBinding::EventInit) -> Fallible<Temporary<Event>> {
let roots = RootCollection::new(); let mut ev = Event::new(global).root();
let mut ev = Event::new(global).root(&roots);
ev.InitEvent(type_, init.bubbles, init.cancelable); ev.InitEvent(type_, init.bubbles, init.cancelable);
Ok(Temporary::new_rooted(&*ev)) Ok(Temporary::new_rooted(&*ev))
} }

5
src/components/script/dom/eventdispatcher.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::callback::ReportExceptions; use dom::bindings::callback::ReportExceptions;
use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, NodeDerived}; use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, NodeDerived};
use dom::bindings::js::{JSRef, OptionalAssignable, RootCollection, Root}; use dom::bindings::js::{JSRef, OptionalAssignable, Root};
use dom::eventtarget::{Capturing, Bubbling, EventTarget}; use dom::eventtarget::{Capturing, Bubbling, EventTarget};
use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing, EventMethods}; use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing, EventMethods};
use dom::node::{Node, NodeHelpers}; use dom::node::{Node, NodeHelpers};
@ -13,7 +13,6 @@ use dom::node::{Node, NodeHelpers};
pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>, pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
pseudo_target: Option<JSRef<'b, EventTarget>>, pseudo_target: Option<JSRef<'b, EventTarget>>,
event: &mut JSRef<Event>) -> bool { event: &mut JSRef<Event>) -> bool {
let roots = RootCollection::new();
assert!(!event.get().dispatching); assert!(!event.get().dispatching);
{ {
@ -32,7 +31,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
let target_node: &JSRef<Node> = NodeCast::to_ref(target).unwrap(); let target_node: &JSRef<Node> = NodeCast::to_ref(target).unwrap();
target_node.ancestors().map(|ancestor| { target_node.ancestors().map(|ancestor| {
let ancestor_target: &JSRef<EventTarget> = EventTargetCast::from_ref(&ancestor); let ancestor_target: &JSRef<EventTarget> = EventTargetCast::from_ref(&ancestor);
ancestor_target.unrooted().root(&roots) ancestor_target.unrooted().root()
}).collect() }).collect()
} else { } else {
vec!() vec!()

5
src/components/script/dom/htmlbuttonelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLButtonElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLButtonElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLButtonElementDerived; use dom::bindings::codegen::InheritTypes::HTMLButtonElementDerived;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLButtonElementTypeId; use dom::element::HTMLButtonElementTypeId;
@ -167,8 +167,7 @@ impl<'a> HTMLButtonElementMethods for JSRef<'a, HTMLButtonElement> {
} }
fn Validity(&self) -> Temporary<ValidityState> { fn Validity(&self) -> Temporary<ValidityState> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
ValidityState::new(&*window) ValidityState::new(&*window)
} }

19
src/components/script/dom/htmlcollection.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
use dom::bindings::codegen::BindingDeclarations::HTMLCollectionBinding; use dom::bindings::codegen::BindingDeclarations::HTMLCollectionBinding;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::{Element, AttributeHandlers}; use dom::element::{Element, AttributeHandlers};
use dom::node::{Node, NodeHelpers}; use dom::node::{Node, NodeHelpers};
@ -129,12 +129,11 @@ pub trait HTMLCollectionMethods {
impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> { impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
// http://dom.spec.whatwg.org/#dom-htmlcollection-length // http://dom.spec.whatwg.org/#dom-htmlcollection-length
fn Length(&self) -> u32 { fn Length(&self) -> u32 {
let roots = RootCollection::new();
match self.collection { match self.collection {
Static(ref elems) => elems.len() as u32, Static(ref elems) => elems.len() as u32,
Live(ref root, ref filter) => { Live(ref root, ref filter) => {
let root = root.root(&roots); let root = root.root();
root.deref().traverse_preorder(&roots) root.deref().traverse_preorder()
.count(|child| { .count(|child| {
let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&child); let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&child);
elem.map_or(false, |elem| filter.filter(elem, &*root)) elem.map_or(false, |elem| filter.filter(elem, &*root))
@ -145,15 +144,14 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
// http://dom.spec.whatwg.org/#dom-htmlcollection-item // http://dom.spec.whatwg.org/#dom-htmlcollection-item
fn Item(&self, index: u32) -> Option<Temporary<Element>> { fn Item(&self, index: u32) -> Option<Temporary<Element>> {
let roots = RootCollection::new();
match self.collection { match self.collection {
Static(ref elems) => elems Static(ref elems) => elems
.as_slice() .as_slice()
.get(index as uint) .get(index as uint)
.map(|elem| Temporary::new(elem.clone())), .map(|elem| Temporary::new(elem.clone())),
Live(ref root, ref filter) => { Live(ref root, ref filter) => {
let root = root.root(&roots); let root = root.root();
root.deref().traverse_preorder(&roots) root.deref().traverse_preorder()
.filter_map(|node| { .filter_map(|node| {
let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&node); let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&node);
elem.filtered(|&elem| filter.filter(elem, &*root)) elem.filtered(|&elem| filter.filter(elem, &*root))
@ -168,7 +166,6 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
// http://dom.spec.whatwg.org/#dom-htmlcollection-nameditem // http://dom.spec.whatwg.org/#dom-htmlcollection-nameditem
fn NamedItem(&self, key: DOMString) -> Option<Temporary<Element>> { fn NamedItem(&self, key: DOMString) -> Option<Temporary<Element>> {
let roots = RootCollection::new();
// Step 1. // Step 1.
if key.is_empty() { if key.is_empty() {
@ -178,14 +175,14 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
// Step 2. // Step 2.
match self.collection { match self.collection {
Static(ref elems) => elems.iter() Static(ref elems) => elems.iter()
.map(|elem| elem.root(&roots)) .map(|elem| elem.root())
.find(|elem| { .find(|elem| {
elem.get_string_attribute("name") == key || elem.get_string_attribute("name") == key ||
elem.get_string_attribute("id") == key }) elem.get_string_attribute("id") == key })
.map(|maybe_elem| Temporary::new_rooted(&*maybe_elem)), .map(|maybe_elem| Temporary::new_rooted(&*maybe_elem)),
Live(ref root, ref filter) => { Live(ref root, ref filter) => {
let root = root.root(&roots); let root = root.root();
root.deref().traverse_preorder(&roots) root.deref().traverse_preorder()
.filter_map(|node| { .filter_map(|node| {
let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&node); let elem: Option<&JSRef<Element>> = ElementCast::to_ref(&node);
elem.filtered(|&elem| filter.filter(elem, &*root)) elem.filtered(|&elem| filter.filter(elem, &*root))

5
src/components/script/dom/htmldatalistelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLDataListElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLDataListElementBinding;
use dom::bindings::codegen::InheritTypes::{HTMLDataListElementDerived, NodeCast}; use dom::bindings::codegen::InheritTypes::{HTMLDataListElementDerived, NodeCast};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::document::Document; use dom::document::Document;
use dom::element::{Element, HTMLDataListElementTypeId}; use dom::element::{Element, HTMLDataListElementTypeId};
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -52,10 +52,9 @@ impl<'a> HTMLDataListElementMethods for JSRef<'a, HTMLDataListElement> {
elem.get().local_name == ~"option" elem.get().local_name == ~"option"
} }
} }
let roots = RootCollection::new();
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
let filter = ~HTMLDataListOptionsFilter; let filter = ~HTMLDataListOptionsFilter;
let window = window_from_node(node).root(&roots); let window = window_from_node(node).root();
HTMLCollection::create(&*window, node, filter) HTMLCollection::create(&*window, node, filter)
} }
} }

8
src/components/script/dom/htmlfieldsetelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLFieldSetElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLFieldSetElementBinding;
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLFieldSetElementDerived, NodeCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLFieldSetElementDerived, NodeCast};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::{Element, HTMLFieldSetElementTypeId}; use dom::element::{Element, HTMLFieldSetElementTypeId};
@ -94,10 +94,9 @@ impl<'a> HTMLFieldSetElementMethods for JSRef<'a, HTMLFieldSetElement> {
elem != root && tag_names.iter().any(|&tag_name| tag_name == elem.get().local_name) elem != root && tag_names.iter().any(|&tag_name| tag_name == elem.get().local_name)
} }
} }
let roots = RootCollection::new();
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
let filter = ~ElementsFilter; let filter = ~ElementsFilter;
let window = window_from_node(node).root(&roots); let window = window_from_node(node).root();
HTMLCollection::create(&*window, node, filter) HTMLCollection::create(&*window, node, filter)
} }
@ -106,8 +105,7 @@ impl<'a> HTMLFieldSetElementMethods for JSRef<'a, HTMLFieldSetElement> {
} }
fn Validity(&self) -> Temporary<ValidityState> { fn Validity(&self) -> Temporary<ValidityState> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
ValidityState::new(&*window) ValidityState::new(&*window)
} }

5
src/components/script/dom/htmlformelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLFormElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLFormElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLFormElementDerived; use dom::bindings::codegen::InheritTypes::HTMLFormElementDerived;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::{Element, HTMLFormElementTypeId}; use dom::element::{Element, HTMLFormElementTypeId};
@ -143,8 +143,7 @@ impl<'a> HTMLFormElementMethods for JSRef<'a, HTMLFormElement> {
fn Elements(&self) -> Temporary<HTMLCollection> { fn Elements(&self) -> Temporary<HTMLCollection> {
// FIXME: https://github.com/mozilla/servo/issues/1844 // FIXME: https://github.com/mozilla/servo/issues/1844
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
HTMLCollection::new(&*window, Static(vec!())) HTMLCollection::new(&*window, Static(vec!()))
} }

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLImageElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLImageElementBinding;
use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, HTMLElementCast, HTMLImageElementDerived}; use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, HTMLElementCast, HTMLImageElementDerived};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::bindings::js::{JS, JSRef, Temporary, RootCollection}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::trace::Untraceable; use dom::bindings::trace::Untraceable;
use dom::document::Document; use dom::document::Document;
use dom::element::{Element, HTMLImageElementTypeId}; use dom::element::{Element, HTMLImageElementTypeId};
@ -43,11 +43,10 @@ impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
/// Makes the local `image` member match the status of the `src` attribute and starts /// Makes the local `image` member match the status of the `src` attribute and starts
/// prefetching the image. This method must be called after `src` is changed. /// prefetching the image. This method must be called after `src` is changed.
fn update_image(&mut self, value: Option<DOMString>, url: Option<Url>) { fn update_image(&mut self, value: Option<DOMString>, url: Option<Url>) {
let roots = RootCollection::new();
let self_alias = self.clone(); let self_alias = self.clone();
let node_alias: &JSRef<Node> = NodeCast::from_ref(&self_alias); let node_alias: &JSRef<Node> = NodeCast::from_ref(&self_alias);
let document = node_alias.owner_doc().root(&roots); let document = node_alias.owner_doc().root();
let window = document.deref().window.root(&roots); let window = document.deref().window.root();
let image_cache = &window.image_cache_task; let image_cache = &window.image_cache_task;
match value { match value {
None => { None => {
@ -275,14 +274,13 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLImageElement> {
} }
fn after_set_attr(&mut self, name: DOMString, value: DOMString) { fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
let roots = RootCollection::new();
match self.super_type() { match self.super_type() {
Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()), Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()),
_ => (), _ => (),
} }
if "src" == name { if "src" == name {
let window = window_from_node(self).root(&roots); let window = window_from_node(self).root();
let url = Some(window.get().get_url()); let url = Some(window.get().get_url());
self.update_image(Some(value), url); self.update_image(Some(value), url);
} }

5
src/components/script/dom/htmlmapelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLMapElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLMapElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLMapElementDerived; use dom::bindings::codegen::InheritTypes::HTMLMapElementDerived;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLMapElementTypeId; use dom::element::HTMLMapElementTypeId;
@ -57,9 +57,8 @@ impl<'a> HTMLMapElementMethods for JSRef<'a, HTMLMapElement> {
} }
fn Areas(&self) -> Temporary<HTMLCollection> { fn Areas(&self) -> Temporary<HTMLCollection> {
let roots = RootCollection::new();
// FIXME: https://github.com/mozilla/servo/issues/1845 // FIXME: https://github.com/mozilla/servo/issues/1845
let window = window_from_node(self).root(&roots); let window = window_from_node(self).root();
HTMLCollection::new(&*window, Static(vec!())) HTMLCollection::new(&*window, Static(vec!()))
} }
} }

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

@ -6,7 +6,7 @@ use dom::attr::AttrMethods;
use dom::bindings::codegen::BindingDeclarations::HTMLObjectElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLObjectElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLObjectElementDerived; use dom::bindings::codegen::InheritTypes::HTMLObjectElementDerived;
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::{Element, HTMLObjectElementTypeId}; use dom::element::{Element, HTMLObjectElementTypeId};
@ -62,12 +62,11 @@ impl<'a> ProcessDataURL for JSRef<'a, HTMLObjectElement> {
// Makes the local `data` member match the status of the `data` attribute and starts // Makes the local `data` member match the status of the `data` attribute and starts
/// prefetching the image. This method must be called after `data` is changed. /// prefetching the image. This method must be called after `data` is changed.
fn process_data_url(&mut self, image_cache: ImageCacheTask, url: Option<Url>) { fn process_data_url(&mut self, image_cache: ImageCacheTask, url: Option<Url>) {
let roots = RootCollection::new();
let elem: &JSRef<Element> = ElementCast::from_ref(self); let elem: &JSRef<Element> = ElementCast::from_ref(self);
// TODO: support other values // TODO: support other values
match (elem.get_attribute(Null, "type").map(|x| x.root(&roots).Value()), match (elem.get_attribute(Null, "type").map(|x| x.root().Value()),
elem.get_attribute(Null, "data").map(|x| x.root(&roots).Value())) { elem.get_attribute(Null, "data").map(|x| x.root().Value())) {
(None, Some(uri)) => { (None, Some(uri)) => {
if is_image_data(uri) { if is_image_data(uri) {
let data_url = parse_url(uri, url); let data_url = parse_url(uri, url);
@ -190,8 +189,7 @@ impl<'a> HTMLObjectElementMethods for JSRef<'a, HTMLObjectElement> {
} }
fn Validity(&self) -> Temporary<ValidityState> { fn Validity(&self) -> Temporary<ValidityState> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
ValidityState::new(&*window) ValidityState::new(&*window)
} }
@ -298,14 +296,13 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLObjectElement> {
} }
fn after_set_attr(&mut self, name: DOMString, value: DOMString) { fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
let roots = RootCollection::new();
match self.super_type() { match self.super_type() {
Some(ref mut s) => s.after_set_attr(name.clone(), value), Some(ref mut s) => s.after_set_attr(name.clone(), value),
_ => (), _ => (),
} }
if "data" == name { if "data" == name {
let window = window_from_node(self).root(&roots); let window = window_from_node(self).root();
let url = Some(window.get().get_url()); let url = Some(window.get().get_url());
self.process_data_url(window.get().image_cache_task.clone(), url); self.process_data_url(window.get().image_cache_task.clone(), url);
} }

5
src/components/script/dom/htmloutputelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLOutputElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLOutputElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLOutputElementDerived; use dom::bindings::codegen::InheritTypes::HTMLOutputElementDerived;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLOutputElementTypeId; use dom::element::HTMLOutputElementTypeId;
@ -102,8 +102,7 @@ impl<'a> HTMLOutputElementMethods for JSRef<'a, HTMLOutputElement> {
} }
fn Validity(&self) -> Temporary<ValidityState> { fn Validity(&self) -> Temporary<ValidityState> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
ValidityState::new(&*window) ValidityState::new(&*window)
} }

5
src/components/script/dom/htmlselectelement.rs
View file

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLSelectElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLSelectElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLSelectElementDerived; use dom::bindings::codegen::InheritTypes::HTMLSelectElementDerived;
use dom::bindings::codegen::UnionTypes::{HTMLElementOrLong, HTMLOptionElementOrHTMLOptGroupElement}; use dom::bindings::codegen::UnionTypes::{HTMLElementOrLong, HTMLOptionElementOrHTMLOptGroupElement};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::{Element, HTMLSelectElementTypeId}; use dom::element::{Element, HTMLSelectElementTypeId};
@ -192,8 +192,7 @@ impl<'a> HTMLSelectElementMethods for JSRef<'a, HTMLSelectElement> {
} }
fn Validity(&self) -> Temporary<ValidityState> { fn Validity(&self) -> Temporary<ValidityState> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
ValidityState::new(&*window) ValidityState::new(&*window)
} }

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

@ -7,7 +7,7 @@ use dom::attr::Attr;
use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, CommentCast, NodeCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, CommentCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, CharacterDataCast}; use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, CharacterDataCast};
use dom::bindings::codegen::InheritTypes::ProcessingInstructionCast; use dom::bindings::codegen::InheritTypes::ProcessingInstructionCast;
use dom::bindings::js::{JSRef, RootCollection}; use dom::bindings::js::JSRef;
use dom::characterdata::CharacterData; use dom::characterdata::CharacterData;
use dom::comment::Comment; use dom::comment::Comment;
use dom::documenttype::DocumentType; use dom::documenttype::DocumentType;
@ -70,9 +70,8 @@ fn serialize_comment(comment: &JSRef<Comment>) -> ~str {
} }
fn serialize_text(text: &JSRef<Text>) -> ~str { fn serialize_text(text: &JSRef<Text>) -> ~str {
let roots = RootCollection::new();
let text_node: &JSRef<Node> = NodeCast::from_ref(text); let text_node: &JSRef<Node> = NodeCast::from_ref(text);
match text_node.parent_node().map(|node| node.root(&roots)) { match text_node.parent_node().map(|node| node.root()) {
Some(ref parent) if parent.is_element() => { Some(ref parent) if parent.is_element() => {
let elem: &JSRef<Element> = ElementCast::to_ref(&**parent).unwrap(); let elem: &JSRef<Element> = ElementCast::to_ref(&**parent).unwrap();
match elem.get().local_name.as_slice() { match elem.get().local_name.as_slice() {
@ -97,17 +96,16 @@ fn serialize_doctype(doctype: &JSRef<DocumentType>) -> ~str {
} }
fn serialize_elem(elem: &JSRef<Element>, open_elements: &mut Vec<~str>) -> ~str { fn serialize_elem(elem: &JSRef<Element>, open_elements: &mut Vec<~str>) -> ~str {
let roots = RootCollection::new();
let mut rv = ~"<" + elem.get().local_name; let mut rv = ~"<" + elem.get().local_name;
for attr in elem.get().attrs.iter() { for attr in elem.get().attrs.iter() {
let attr = attr.root(&roots); let attr = attr.root();
rv.push_str(serialize_attr(&*attr)); rv.push_str(serialize_attr(&*attr));
}; };
rv.push_str(">"); rv.push_str(">");
match elem.get().local_name.as_slice() { match elem.get().local_name.as_slice() {
"pre" | "listing" | "textarea" if elem.get().namespace == namespace::HTML => { "pre" | "listing" | "textarea" if elem.get().namespace == namespace::HTML => {
let node: &JSRef<Node> = NodeCast::from_ref(elem); let node: &JSRef<Node> = NodeCast::from_ref(elem);
match node.first_child().map(|child| child.root(&roots)) { match node.first_child().map(|child| child.root()) {
Some(ref child) if child.is_text() => { Some(ref child) if child.is_text() => {
let text: &JSRef<CharacterData> = CharacterDataCast::to_ref(&**child).unwrap(); let text: &JSRef<CharacterData> = CharacterDataCast::to_ref(&**child).unwrap();
if text.get().data.len() > 0 && text.get().data[0] == 0x0A as u8 { if text.get().data.len() > 0 && text.get().data[0] == 0x0A as u8 {

5
src/components/script/dom/htmlstyleelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLStyleElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLStyleElementBinding;
use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLStyleElementDerived, NodeCast}; use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLStyleElementDerived, NodeCast};
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLStyleElementTypeId; use dom::element::HTMLStyleElementTypeId;
@ -93,9 +93,8 @@ pub trait StyleElementHelpers {
impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> { impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
fn parse_own_css(&self) { fn parse_own_css(&self) {
let roots = RootCollection::new();
let node: &JSRef<Node> = NodeCast::from_ref(self); let node: &JSRef<Node> = NodeCast::from_ref(self);
let win = window_from_node(node).root(&roots); let win = window_from_node(node).root();
let url = win.get().page().get_url(); let url = win.get().page().get_url();
let data = node.GetTextContent().expect("Element.textContent must be a string"); let data = node.GetTextContent().expect("Element.textContent must be a string");

9
src/components/script/dom/mouseevent.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::MouseEventBinding; use dom::bindings::codegen::BindingDeclarations::MouseEventBinding;
use dom::bindings::codegen::InheritTypes::{UIEventCast, MouseEventDerived}; use dom::bindings::codegen::InheritTypes::{UIEventCast, MouseEventDerived};
use dom::bindings::js::{JS, JSRef, RootCollection, RootedReference, Temporary}; use dom::bindings::js::{JS, JSRef, RootedReference, Temporary};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, MouseEventTypeId}; use dom::event::{Event, MouseEventTypeId};
@ -60,10 +60,9 @@ impl MouseEvent {
pub fn Constructor(owner: &JSRef<Window>, pub fn Constructor(owner: &JSRef<Window>,
type_: DOMString, type_: DOMString,
init: &MouseEventBinding::MouseEventInit) -> Fallible<Temporary<MouseEvent>> { init: &MouseEventBinding::MouseEventInit) -> Fallible<Temporary<MouseEvent>> {
let roots = RootCollection::new(); let mut ev = MouseEvent::new(owner).root();
let mut ev = MouseEvent::new(owner).root(&roots); let view = init.view.as_ref().map(|view| view.root());
let view = init.view.as_ref().map(|view| view.root(&roots)); let related_target = init.relatedTarget.as_ref().map(|relatedTarget| relatedTarget.root());
let related_target = init.relatedTarget.as_ref().map(|relatedTarget| relatedTarget.root(&roots));
ev.InitMouseEvent(type_, init.bubbles, init.cancelable, view.root_ref(), ev.InitMouseEvent(type_, init.bubbles, init.cancelable, view.root_ref(),
init.detail, init.screenX, init.screenY, init.detail, init.screenX, init.screenY,
init.clientX, init.clientY, init.ctrlKey, init.clientX, init.clientY, init.ctrlKey,

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

@ -10,7 +10,7 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, NodeCast, Elem
use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeBase, NodeDerived}; use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeBase, NodeDerived};
use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTargetCast}; use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTargetCast};
use dom::bindings::codegen::BindingDeclarations::NodeBinding::NodeConstants; use dom::bindings::codegen::BindingDeclarations::NodeBinding::NodeConstants;
use dom::bindings::js::{JS, JSRef, RootCollection, RootedReference, Temporary, Root}; use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root};
use dom::bindings::js::{OptionalAssignable, TemporaryPushable, OptionalRootedRootable}; use dom::bindings::js::{OptionalAssignable, TemporaryPushable, OptionalRootedRootable};
use dom::bindings::js::{ResultRootable, OptionalRootable}; use dom::bindings::js::{ResultRootable, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -240,29 +240,26 @@ trait PrivateNodeHelpers {
impl<'a> PrivateNodeHelpers for JSRef<'a, Node> { impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#node-is-inserted // http://dom.spec.whatwg.org/#node-is-inserted
fn node_inserted(&self) { fn node_inserted(&self) {
let roots = RootCollection::new();
assert!(self.parent_node().is_some()); assert!(self.parent_node().is_some());
let document = document_from_node(self).root(&roots); let document = document_from_node(self).root();
if self.is_in_doc() { if self.is_in_doc() {
for node in self.traverse_preorder(&roots) { for node in self.traverse_preorder() {
vtable_for(&node).bind_to_tree(); vtable_for(&node).bind_to_tree();
} }
} }
self.parent_node().root(&roots) self.parent_node().root().map(|parent| vtable_for(&*parent).child_inserted(self));
.map(|parent| vtable_for(&*parent).child_inserted(self));
document.deref().content_changed(); document.deref().content_changed();
} }
// http://dom.spec.whatwg.org/#node-is-removed // http://dom.spec.whatwg.org/#node-is-removed
fn node_removed(&self) { fn node_removed(&self) {
let roots = RootCollection::new();
assert!(self.parent_node().is_none()); assert!(self.parent_node().is_none());
let document = document_from_node(self).root(&roots); let document = document_from_node(self).root();
for node in self.traverse_preorder(&roots) { for node in self.traverse_preorder() {
// XXX how about if the node wasn't in the tree in the first place? // XXX how about if the node wasn't in the tree in the first place?
vtable_for(&node).unbind_from_tree(); vtable_for(&node).unbind_from_tree();
} }
@ -278,7 +275,6 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
/// ///
/// Fails unless `new_child` is disconnected from the tree. /// Fails unless `new_child` is disconnected from the tree.
fn add_child(&mut self, new_child: &mut JSRef<Node>, mut before: Option<JSRef<Node>>) { fn add_child(&mut self, new_child: &mut JSRef<Node>, mut before: Option<JSRef<Node>>) {
let roots = RootCollection::new();
assert!(new_child.parent_node().is_none()); assert!(new_child.parent_node().is_none());
assert!(new_child.prev_sibling().is_none()); assert!(new_child.prev_sibling().is_none());
assert!(new_child.next_sibling().is_none()); assert!(new_child.next_sibling().is_none());
@ -286,14 +282,13 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
Some(ref mut before) => { Some(ref mut before) => {
// XXX Should assert that parent is self. // XXX Should assert that parent is self.
assert!(before.parent_node().is_some()); assert!(before.parent_node().is_some());
match before.prev_sibling() { match before.prev_sibling().root() {
None => { None => {
// XXX Should assert that before is the first child of // XXX Should assert that before is the first child of
// self. // self.
self.set_first_child(Some(new_child.clone())); self.set_first_child(Some(new_child.clone()));
}, },
Some(prev_sibling) => { Some(mut prev_sibling) => {
let mut prev_sibling = prev_sibling.root(&roots);
prev_sibling.set_next_sibling(Some(new_child.clone())); prev_sibling.set_next_sibling(Some(new_child.clone()));
new_child.set_prev_sibling(Some((*prev_sibling).clone())); new_child.set_prev_sibling(Some((*prev_sibling).clone()));
}, },
@ -302,7 +297,7 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
new_child.set_next_sibling(Some(before.clone())); new_child.set_next_sibling(Some(before.clone()));
}, },
None => { None => {
match self.last_child().map(|child| child.root(&roots)) { match self.last_child().root() {
None => self.set_first_child(Some(new_child.clone())), None => self.set_first_child(Some(new_child.clone())),
Some(mut last_child) => { Some(mut last_child) => {
assert!(last_child.next_sibling().is_none()); assert!(last_child.next_sibling().is_none());
@ -322,27 +317,26 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
/// ///
/// Fails unless `child` is a child of this node. (FIXME: This is not yet checked.) /// Fails unless `child` is a child of this node. (FIXME: This is not yet checked.)
fn remove_child(&mut self, child: &mut JSRef<Node>) { fn remove_child(&mut self, child: &mut JSRef<Node>) {
let roots = RootCollection::new();
assert!(child.parent_node.is_some()); assert!(child.parent_node.is_some());
match child.prev_sibling.root(&roots) { match child.prev_sibling.root() {
None => { None => {
let next_sibling = child.next_sibling.as_ref().map(|next| next.root(&roots)); let next_sibling = child.next_sibling.root();
self.set_first_child(next_sibling.root_ref()); self.set_first_child(next_sibling.root_ref());
} }
Some(ref mut prev_sibling) => { Some(ref mut prev_sibling) => {
let next_sibling = child.next_sibling.as_ref().map(|next| next.root(&roots)); let next_sibling = child.next_sibling.root();
prev_sibling.set_next_sibling(next_sibling.root_ref()); prev_sibling.set_next_sibling(next_sibling.root_ref());
} }
} }
match child.next_sibling.root(&roots) { match child.next_sibling.root() {
None => { None => {
let prev_sibling = child.prev_sibling.as_ref().map(|prev| prev.root(&roots)); let prev_sibling = child.prev_sibling.root();
self.set_last_child(prev_sibling.root_ref()); self.set_last_child(prev_sibling.root_ref());
} }
Some(ref mut next_sibling) => { Some(ref mut next_sibling) => {
let prev_sibling = child.prev_sibling.as_ref().map(|prev| prev.root(&roots)); let prev_sibling = child.prev_sibling.root();
next_sibling.set_prev_sibling(prev_sibling.root_ref()); next_sibling.set_prev_sibling(prev_sibling.root_ref());
} }
} }
@ -357,36 +351,31 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
// //
fn set_parent_node(&mut self, new_parent_node: Option<JSRef<Node>>) { fn set_parent_node(&mut self, new_parent_node: Option<JSRef<Node>>) {
let roots = RootCollection::new(); let doc = self.owner_doc().root();
let doc = self.owner_doc().root(&roots);
doc.deref().wait_until_safe_to_modify_dom(); doc.deref().wait_until_safe_to_modify_dom();
self.parent_node.assign(new_parent_node); self.parent_node.assign(new_parent_node);
} }
fn set_first_child(&mut self, new_first_child: Option<JSRef<Node>>) { fn set_first_child(&mut self, new_first_child: Option<JSRef<Node>>) {
let roots = RootCollection::new(); let doc = self.owner_doc().root();
let doc = self.owner_doc().root(&roots);
doc.deref().wait_until_safe_to_modify_dom(); doc.deref().wait_until_safe_to_modify_dom();
self.first_child.assign(new_first_child); self.first_child.assign(new_first_child);
} }
fn set_last_child(&mut self, new_last_child: Option<JSRef<Node>>) { fn set_last_child(&mut self, new_last_child: Option<JSRef<Node>>) {
let roots = RootCollection::new(); let doc = self.owner_doc().root();
let doc = self.owner_doc().root(&roots);
doc.deref().wait_until_safe_to_modify_dom(); doc.deref().wait_until_safe_to_modify_dom();
self.last_child.assign(new_last_child); self.last_child.assign(new_last_child);
} }
fn set_prev_sibling(&mut self, new_prev_sibling: Option<JSRef<Node>>) { fn set_prev_sibling(&mut self, new_prev_sibling: Option<JSRef<Node>>) {
let roots = RootCollection::new(); let doc = self.owner_doc().root();
let doc = self.owner_doc().root(&roots);
doc.deref().wait_until_safe_to_modify_dom(); doc.deref().wait_until_safe_to_modify_dom();
self.prev_sibling.assign(new_prev_sibling); self.prev_sibling.assign(new_prev_sibling);
} }
fn set_next_sibling(&mut self, new_next_sibling: Option<JSRef<Node>>) { fn set_next_sibling(&mut self, new_next_sibling: Option<JSRef<Node>>) {
let roots = RootCollection::new(); let doc = self.owner_doc().root();
let doc = self.owner_doc().root(&roots);
doc.deref().wait_until_safe_to_modify_dom(); doc.deref().wait_until_safe_to_modify_dom();
self.next_sibling.assign(new_next_sibling); self.next_sibling.assign(new_next_sibling);
} }
@ -427,8 +416,8 @@ pub trait NodeHelpers {
fn dump_indent(&self, indent: uint); fn dump_indent(&self, indent: uint);
fn debug_str(&self) -> ~str; fn debug_str(&self) -> ~str;
fn traverse_preorder<'a>(&self, roots: &'a RootCollection) -> TreeIterator<'a>; fn traverse_preorder<'a>(&self) -> TreeIterator<'a>;
fn sequential_traverse_postorder<'a>(&self, roots: &'a RootCollection) -> TreeIterator<'a>; fn sequential_traverse_postorder<'a>(&self) -> TreeIterator<'a>;
fn inclusively_following_siblings(&self) -> AbstractNodeChildrenIterator; fn inclusively_following_siblings(&self) -> AbstractNodeChildrenIterator;
fn to_trusted_node_address(&self) -> TrustedNodeAddress; fn to_trusted_node_address(&self) -> TrustedNodeAddress;
@ -546,24 +535,22 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
/// Iterates over this node and all its descendants, in preorder. /// Iterates over this node and all its descendants, in preorder.
fn traverse_preorder<'a>(&self, roots: &'a RootCollection) -> TreeIterator<'a> { fn traverse_preorder<'a>(&self) -> TreeIterator<'a> {
let mut nodes = vec!(); let mut nodes = vec!();
gather_abstract_nodes(self, roots, &mut nodes, false); gather_abstract_nodes(self, &mut nodes, false);
TreeIterator::new(nodes) TreeIterator::new(nodes)
} }
/// Iterates over this node and all its descendants, in postorder. /// Iterates over this node and all its descendants, in postorder.
fn sequential_traverse_postorder<'a>(&self, roots: &'a RootCollection) -> TreeIterator<'a> { fn sequential_traverse_postorder<'a>(&self) -> TreeIterator<'a> {
let mut nodes = vec!(); let mut nodes = vec!();
gather_abstract_nodes(self, roots, &mut nodes, true); gather_abstract_nodes(self, &mut nodes, true);
TreeIterator::new(nodes) TreeIterator::new(nodes)
} }
fn inclusively_following_siblings(&self) -> AbstractNodeChildrenIterator { fn inclusively_following_siblings(&self) -> AbstractNodeChildrenIterator {
let roots = RootCollection::new();
AbstractNodeChildrenIterator { AbstractNodeChildrenIterator {
current_node: Some((*self.unrooted().root(&roots)).clone()), current_node: Some((*self.unrooted().root()).clone()),
roots: roots,
} }
} }
@ -572,10 +559,8 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn following_siblings(&self) -> AbstractNodeChildrenIterator { fn following_siblings(&self) -> AbstractNodeChildrenIterator {
let roots = RootCollection::new();
AbstractNodeChildrenIterator { AbstractNodeChildrenIterator {
current_node: self.next_sibling().map(|node| (*node.root(&roots)).clone()), current_node: self.next_sibling().map(|node| (*node.root()).clone()),
roots: roots,
} }
} }
@ -591,8 +576,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn get_bounding_content_box(&self) -> Rect<Au> { fn get_bounding_content_box(&self) -> Rect<Au> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
let page = window.get().page(); let page = window.get().page();
let (chan, port) = channel(); let (chan, port) = channel();
let addr = self.to_trusted_node_address(); let addr = self.to_trusted_node_address();
@ -601,8 +585,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn get_content_boxes(&self) -> Vec<Rect<Au>> { fn get_content_boxes(&self) -> Vec<Rect<Au>> {
let roots = RootCollection::new(); let window = window_from_node(self).root();
let window = window_from_node(self).root(&roots);
let page = window.get().page(); let page = window.get().page();
let (chan, port) = channel(); let (chan, port) = channel();
let addr = self.to_trusted_node_address(); let addr = self.to_trusted_node_address();
@ -611,10 +594,8 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn ancestors(&self) -> AncestorIterator { fn ancestors(&self) -> AncestorIterator {
let roots = RootCollection::new();
AncestorIterator { AncestorIterator {
current: self.parent_node.clone().map(|node| (*node.root(&roots)).clone()), current: self.parent_node.clone().map(|node| (*node.root()).clone()),
roots: roots,
} }
} }
@ -627,10 +608,8 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn children(&self) -> AbstractNodeChildrenIterator { fn children(&self) -> AbstractNodeChildrenIterator {
let roots = RootCollection::new();
AbstractNodeChildrenIterator { AbstractNodeChildrenIterator {
current_node: self.first_child.clone().map(|node| (*node.root(&roots)).clone()), current_node: self.first_child.clone().map(|node| (*node.root()).clone()),
roots: roots,
} }
} }
@ -646,8 +625,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn wait_until_safe_to_modify_dom(&self) { fn wait_until_safe_to_modify_dom(&self) {
let roots = RootCollection::new(); let document = self.owner_doc().root();
let document = self.owner_doc().root(&roots);
document.deref().wait_until_safe_to_modify_dom(); document.deref().wait_until_safe_to_modify_dom();
} }
@ -743,14 +721,13 @@ pub type ChildElementIterator<'a, 'b> = Map<'a, JSRef<'b, Node>,
pub struct AbstractNodeChildrenIterator<'a> { pub struct AbstractNodeChildrenIterator<'a> {
current_node: Option<JSRef<'a, Node>>, current_node: Option<JSRef<'a, Node>>,
roots: RootCollection,
} }
impl<'a> Iterator<JSRef<'a, Node>> for AbstractNodeChildrenIterator<'a> { impl<'a> Iterator<JSRef<'a, Node>> for AbstractNodeChildrenIterator<'a> {
fn next(&mut self) -> Option<JSRef<'a, Node>> { fn next(&mut self) -> Option<JSRef<'a, Node>> {
let node = self.current_node.clone(); let node = self.current_node.clone();
self.current_node = node.clone().and_then(|node| { self.current_node = node.clone().and_then(|node| {
node.next_sibling().map(|node| (*node.root(&self.roots)).clone()) node.next_sibling().map(|node| (*node.root()).clone())
}); });
node node
} }
@ -758,7 +735,6 @@ impl<'a> Iterator<JSRef<'a, Node>> for AbstractNodeChildrenIterator<'a> {
pub struct AncestorIterator<'a> { pub struct AncestorIterator<'a> {
current: Option<JSRef<'a, Node>>, current: Option<JSRef<'a, Node>>,
roots: RootCollection,
} }
impl<'a> Iterator<JSRef<'a, Node>> for AncestorIterator<'a> { impl<'a> Iterator<JSRef<'a, Node>> for AncestorIterator<'a> {
@ -769,7 +745,7 @@ impl<'a> Iterator<JSRef<'a, Node>> for AncestorIterator<'a> {
// FIXME: Do we need two clones here? // FIXME: Do we need two clones here?
let x = self.current.get_ref().clone(); let x = self.current.get_ref().clone();
self.current = x.parent_node().map(|node| (*node.root(&self.roots)).clone()); self.current = x.parent_node().map(|node| (*node.root()).clone());
Some(x) Some(x)
} }
} }
@ -802,8 +778,7 @@ impl<'a> Iterator<JSRef<'a, Node>> for TreeIterator<'a> {
} }
} }
pub struct NodeIterator<'a> { pub struct NodeIterator {
roots: &'a RootCollection,
pub start_node: JS<Node>, pub start_node: JS<Node>,
pub current_node: Option<JS<Node>>, pub current_node: Option<JS<Node>>,
pub depth: uint, pub depth: uint,
@ -811,13 +786,11 @@ pub struct NodeIterator<'a> {
include_descendants_of_void: bool include_descendants_of_void: bool
} }
impl<'a> NodeIterator<'a> { impl NodeIterator {
pub fn new<'a, 'b>(roots: &'a RootCollection, pub fn new<'a>(start_node: &JSRef<'a, Node>,
start_node: &JSRef<'b, Node>, include_start: bool,
include_start: bool, include_descendants_of_void: bool) -> NodeIterator {
include_descendants_of_void: bool) -> NodeIterator<'a> {
NodeIterator { NodeIterator {
roots: roots,
start_node: start_node.unrooted(), start_node: start_node.unrooted(),
current_node: None, current_node: None,
depth: 0, depth: 0,
@ -832,22 +805,22 @@ impl<'a> NodeIterator<'a> {
if elem.get().is_void() { if elem.get().is_void() {
None None
} else { } else {
node.first_child().map(|child| (*child.root(self.roots)).clone()) node.first_child().map(|child| (*child.root()).clone())
} }
} else { } else {
node.first_child().map(|child| (*child.root(self.roots)).clone()) node.first_child().map(|child| (*child.root()).clone())
} }
} }
} }
impl<'a, 'b> Iterator<JSRef<'b, Node>> for NodeIterator<'a> { impl<'a> Iterator<JSRef<'a, Node>> for NodeIterator {
fn next(&mut self) -> Option<JSRef<Node>> { fn next(&mut self) -> Option<JSRef<Node>> {
self.current_node = match self.current_node.as_ref().map(|node| node.root(self.roots)) { self.current_node = match self.current_node.as_ref().map(|node| node.root()) {
None => { None => {
if self.include_start { if self.include_start {
Some(self.start_node.clone()) Some(self.start_node.clone())
} else { } else {
self.next_child(&*self.start_node.root(self.roots)) self.next_child(&*self.start_node.root())
.map(|child| child.unrooted()) .map(|child| child.unrooted())
} }
}, },
@ -859,21 +832,21 @@ impl<'a, 'b> Iterator<JSRef<'b, Node>> for NodeIterator<'a> {
}, },
None if node.deref().unrooted() == self.start_node => None, None if node.deref().unrooted() == self.start_node => None,
None => { None => {
match node.deref().next_sibling().root(self.roots) { match node.deref().next_sibling().root() {
Some(sibling) => Some(sibling.deref().unrooted()), Some(sibling) => Some(sibling.deref().unrooted()),
None => { None => {
let mut candidate = node.deref().clone(); let mut candidate = node.deref().clone();
while candidate.next_sibling().is_none() { while candidate.next_sibling().is_none() {
candidate = (*candidate.parent_node() candidate = (*candidate.parent_node()
.expect("Got to root without reaching start node") .expect("Got to root without reaching start node")
.root(self.roots)).clone(); .root()).clone();
self.depth -= 1; self.depth -= 1;
if candidate.unrooted() == self.start_node { if candidate.unrooted() == self.start_node {
break; break;
} }
} }
if candidate.unrooted() != self.start_node { if candidate.unrooted() != self.start_node {
candidate.next_sibling().map(|node| node.root(self.roots).unrooted()) candidate.next_sibling().map(|node| node.root().unrooted())
} else { } else {
None None
} }
@ -883,19 +856,19 @@ impl<'a, 'b> Iterator<JSRef<'b, Node>> for NodeIterator<'a> {
} }
} }
}; };
self.current_node.clone().map(|node| (*node.root(self.roots)).clone()) self.current_node.clone().map(|node| (*node.root()).clone())
} }
} }
fn gather_abstract_nodes<'a>(cur: &JSRef<Node>, roots: &'a RootCollection, refs: &mut Vec<JSRef<Node>>, postorder: bool) { fn gather_abstract_nodes<'a>(cur: &JSRef<Node>, refs: &mut Vec<JSRef<Node>>, postorder: bool) {
if !postorder { if !postorder {
refs.push((*cur.unrooted().root(roots)).clone()); refs.push((*cur.unrooted().root()).clone());
} }
for kid in cur.children() { for kid in cur.children() {
gather_abstract_nodes(&kid, roots, refs, postorder) gather_abstract_nodes(&kid, refs, postorder)
} }
if postorder { if postorder {
refs.push((*cur.unrooted().root(roots)).clone()); refs.push((*cur.unrooted().root()).clone());
} }
} }
@ -914,17 +887,15 @@ impl Node {
document: &JSRef<Document>, document: &JSRef<Document>,
wrap_fn: extern "Rust" fn(*JSContext, &JSRef<Window>, ~N) -> JS<N>) wrap_fn: extern "Rust" fn(*JSContext, &JSRef<Window>, ~N) -> JS<N>)
-> Temporary<N> { -> Temporary<N> {
let roots = RootCollection::new();
assert!(node.reflector().get_jsobject().is_null()); assert!(node.reflector().get_jsobject().is_null());
let window = document.get().window.root(&roots); let window = document.get().window.root();
let node = reflect_dom_object(node, &window.root_ref(), wrap_fn).root(&roots); let node = reflect_dom_object(node, &window.root_ref(), wrap_fn).root();
assert!(node.reflector().get_jsobject().is_not_null()); assert!(node.reflector().get_jsobject().is_not_null());
Temporary::new_rooted(&*node) Temporary::new_rooted(&*node)
} }
pub fn new_inherited(type_id: NodeTypeId, doc: JS<Document>) -> Node { pub fn new_inherited(type_id: NodeTypeId, doc: JS<Document>) -> Node {
let roots = RootCollection::new(); let doc = doc.root();
let doc = doc.root(&roots);
Node::new_(type_id, Some(doc.root_ref())) Node::new_(type_id, Some(doc.root_ref()))
} }
@ -954,9 +925,8 @@ impl Node {
// http://dom.spec.whatwg.org/#concept-node-adopt // http://dom.spec.whatwg.org/#concept-node-adopt
pub fn adopt(node: &mut JSRef<Node>, document: &JSRef<Document>) { pub fn adopt(node: &mut JSRef<Node>, document: &JSRef<Document>) {
let roots = RootCollection::new();
// Step 1. // Step 1.
match node.parent_node().root(&roots) { match node.parent_node().root() {
Some(mut parent) => { Some(mut parent) => {
Node::remove(node, &mut *parent, Unsuppressed); Node::remove(node, &mut *parent, Unsuppressed);
} }
@ -964,9 +934,9 @@ impl Node {
} }
// Step 2. // Step 2.
let node_doc = document_from_node(node).root(&roots); let node_doc = document_from_node(node).root();
if &*node_doc != document { if &*node_doc != document {
for mut descendant in node.traverse_preorder(&roots) { for mut descendant in node.traverse_preorder() {
descendant.set_owner_doc(document); descendant.set_owner_doc(document);
} }
} }
@ -978,7 +948,6 @@ impl Node {
// http://dom.spec.whatwg.org/#concept-node-pre-insert // http://dom.spec.whatwg.org/#concept-node-pre-insert
fn pre_insert(node: &mut JSRef<Node>, parent: &mut JSRef<Node>, child: Option<JSRef<Node>>) fn pre_insert(node: &mut JSRef<Node>, parent: &mut JSRef<Node>, child: Option<JSRef<Node>>)
-> Fallible<Temporary<Node>> { -> Fallible<Temporary<Node>> {
let roots = RootCollection::new();
// Step 1. // Step 1.
match parent.type_id() { match parent.type_id() {
DocumentNodeTypeId | DocumentNodeTypeId |
@ -1001,13 +970,13 @@ impl Node {
// Step 4-5. // Step 4-5.
match node.type_id() { match node.type_id() {
TextNodeTypeId => { TextNodeTypeId => {
match node.parent_node().root(&roots) { match node.parent_node().root() {
Some(ref parent) if parent.is_document() => return Err(HierarchyRequest), Some(ref parent) if parent.is_document() => return Err(HierarchyRequest),
_ => () _ => ()
} }
} }
DoctypeNodeTypeId => { DoctypeNodeTypeId => {
match node.parent_node().root(&roots) { match node.parent_node().root() {
Some(ref parent) if !parent.is_document() => return Err(HierarchyRequest), Some(ref parent) if !parent.is_document() => return Err(HierarchyRequest),
_ => () _ => ()
} }
@ -1098,12 +1067,12 @@ impl Node {
// Step 7-8. // Step 7-8.
let referenceChild = match child { let referenceChild = match child {
Some(ref child) if child == node => node.next_sibling().map(|node| (*node.root(&roots)).clone()), Some(ref child) if child == node => node.next_sibling().map(|node| (*node.root()).clone()),
_ => child _ => child
}; };
// Step 9. // Step 9.
let document = document_from_node(parent).root(&roots); let document = document_from_node(parent).root();
Node::adopt(node, &*document); Node::adopt(node, &*document);
// Step 10. // Step 10.
@ -1157,12 +1126,11 @@ impl Node {
// http://dom.spec.whatwg.org/#concept-node-replace-all // http://dom.spec.whatwg.org/#concept-node-replace-all
fn replace_all(mut node: Option<JSRef<Node>>, parent: &mut JSRef<Node>) { fn replace_all(mut node: Option<JSRef<Node>>, parent: &mut JSRef<Node>) {
let roots = RootCollection::new();
// Step 1. // Step 1.
match node { match node {
Some(ref mut node) => { Some(ref mut node) => {
let document = document_from_node(parent).root(&roots); let document = document_from_node(parent).root();
Node::adopt(node, &*document); Node::adopt(node, &*document);
} }
None => (), None => (),
@ -1237,12 +1205,11 @@ impl Node {
// http://dom.spec.whatwg.org/#concept-node-clone // http://dom.spec.whatwg.org/#concept-node-clone
pub fn clone(node: &JSRef<Node>, maybe_doc: Option<&JSRef<Document>>, pub fn clone(node: &JSRef<Node>, maybe_doc: Option<&JSRef<Document>>,
clone_children: CloneChildrenFlag) -> Temporary<Node> { clone_children: CloneChildrenFlag) -> Temporary<Node> {
let roots = RootCollection::new();
// Step 1. // Step 1.
let mut document = match maybe_doc { let mut document = match maybe_doc {
Some(doc) => doc.unrooted().root(&roots), Some(doc) => doc.unrooted().root(),
None => node.owner_doc().root(&roots) None => node.owner_doc().root()
}; };
// Step 2. // Step 2.
@ -1272,7 +1239,7 @@ impl Node {
true => HTMLDocument, true => HTMLDocument,
false => NonHTMLDocument false => NonHTMLDocument
}; };
let window = document.window.root(&roots); let window = document.window.root();
let document = Document::new(&*window, Some(document.url().clone()), let document = Document::new(&*window, Some(document.url().clone()),
is_html_doc, None); is_html_doc, None);
NodeCast::from_unrooted(document) NodeCast::from_unrooted(document)
@ -1296,16 +1263,16 @@ impl Node {
pi.characterdata.data.clone(), &*document); pi.characterdata.data.clone(), &*document);
NodeCast::from_unrooted(pi) NodeCast::from_unrooted(pi)
}, },
}.root(&roots); }.root();
// Step 3. // Step 3.
let document = if copy.is_document() { let document = if copy.is_document() {
let doc: &JSRef<Document> = DocumentCast::to_ref(&*copy).unwrap(); let doc: &JSRef<Document> = DocumentCast::to_ref(&*copy).unwrap();
doc.unrooted().root(&roots) doc.unrooted().root()
} else { } else {
document.unrooted().root(&roots) document.unrooted().root()
}; };
assert!(&*copy.owner_doc().root(&roots) == &*document); assert!(&*copy.owner_doc().root() == &*document);
// Step 4 (some data already copied in step 2). // Step 4 (some data already copied in step 2).
match node.get().type_id { match node.get().type_id {
@ -1326,8 +1293,8 @@ impl Node {
let copy_elem = copy_elem.get_mut(); let copy_elem = copy_elem.get_mut();
// FIXME: https://github.com/mozilla/servo/issues/1737 // FIXME: https://github.com/mozilla/servo/issues/1737
copy_elem.namespace = node_elem.namespace.clone(); copy_elem.namespace = node_elem.namespace.clone();
let window = document.get().window.root(&roots); let window = document.get().window.root();
for attr in node_elem.attrs.iter().map(|attr| attr.root(&roots)) { for attr in node_elem.attrs.iter().map(|attr| attr.root()) {
copy_elem.attrs.push_unrooted( copy_elem.attrs.push_unrooted(
Attr::new(&*window, Attr::new(&*window,
attr.deref().local_name.clone(), attr.deref().value.clone(), attr.deref().local_name.clone(), attr.deref().value.clone(),
@ -1343,7 +1310,7 @@ impl Node {
// Step 6. // Step 6.
if clone_children == CloneChildren { if clone_children == CloneChildren {
for ref child in node.children() { for ref child in node.children() {
let mut child_copy = Node::clone(&*child, Some(&*document), clone_children).root(&roots); let mut child_copy = Node::clone(&*child, Some(&*document), clone_children).root();
let _inserted_node = Node::pre_insert(&mut *child_copy, &mut *copy, None); let _inserted_node = Node::pre_insert(&mut *child_copy, &mut *copy, None);
} }
} }
@ -1462,10 +1429,9 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#dom-node-parentelement // http://dom.spec.whatwg.org/#dom-node-parentelement
fn GetParentElement(&self) -> Option<Temporary<Element>> { fn GetParentElement(&self) -> Option<Temporary<Element>> {
let roots = RootCollection::new();
self.parent_node.clone() self.parent_node.clone()
.and_then(|parent| { .and_then(|parent| {
let parent = parent.root(&roots); let parent = parent.root();
ElementCast::to_ref(&*parent).map(|elem| { ElementCast::to_ref(&*parent).map(|elem| {
Temporary::new_rooted(elem) Temporary::new_rooted(elem)
}) })
@ -1479,14 +1445,13 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#dom-node-childnodes // http://dom.spec.whatwg.org/#dom-node-childnodes
fn ChildNodes(&mut self) -> Temporary<NodeList> { fn ChildNodes(&mut self) -> Temporary<NodeList> {
let roots = RootCollection::new();
match self.child_list { match self.child_list {
None => (), None => (),
Some(ref list) => return Temporary::new(list.clone()), Some(ref list) => return Temporary::new(list.clone()),
} }
let doc = self.owner_doc().root(&roots); let doc = self.owner_doc().root();
let window = doc.deref().window.root(&roots); let window = doc.deref().window.root();
let child_list = NodeList::new_child_list(&*window, self); let child_list = NodeList::new_child_list(&*window, self);
self.child_list.assign(Some(child_list)); self.child_list.assign(Some(child_list));
Temporary::new(self.child_list.get_ref().clone()) Temporary::new(self.child_list.get_ref().clone())
@ -1542,12 +1507,11 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#dom-node-textcontent // http://dom.spec.whatwg.org/#dom-node-textcontent
fn GetTextContent(&self) -> Option<DOMString> { fn GetTextContent(&self) -> Option<DOMString> {
let roots = RootCollection::new();
match self.type_id { match self.type_id {
DocumentFragmentNodeTypeId | DocumentFragmentNodeTypeId |
ElementNodeTypeId(..) => { ElementNodeTypeId(..) => {
let mut content = ~""; let mut content = ~"";
for node in self.traverse_preorder(&roots) { for node in self.traverse_preorder() {
if node.is_text() { if node.is_text() {
let text: &JSRef<Text> = TextCast::to_ref(&node).unwrap(); let text: &JSRef<Text> = TextCast::to_ref(&node).unwrap();
content.push_str(text.get().characterdata.data.as_slice()); content.push_str(text.get().characterdata.data.as_slice());
@ -1571,7 +1535,6 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#dom-node-textcontent // http://dom.spec.whatwg.org/#dom-node-textcontent
fn SetTextContent(&mut self, value: Option<DOMString>) fn SetTextContent(&mut self, value: Option<DOMString>)
-> ErrorResult { -> ErrorResult {
let roots = RootCollection::new();
let value = null_str_as_empty(&value); let value = null_str_as_empty(&value);
match self.type_id { match self.type_id {
DocumentFragmentNodeTypeId | DocumentFragmentNodeTypeId |
@ -1580,9 +1543,9 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
let node = if value.len() == 0 { let node = if value.len() == 0 {
None None
} else { } else {
let document = self.owner_doc().root(&roots); let document = self.owner_doc().root();
Some(NodeCast::from_unrooted(document.deref().CreateTextNode(value))) Some(NodeCast::from_unrooted(document.deref().CreateTextNode(value)))
}.root(&roots); }.root();
// Step 3. // Step 3.
Node::replace_all(node.root_ref(), self); Node::replace_all(node.root_ref(), self);
@ -1598,7 +1561,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
} }
// Notify the document that the content of this node is different // Notify the document that the content of this node is different
let document = self.owner_doc().root(&roots); let document = self.owner_doc().root();
document.deref().content_changed(); document.deref().content_changed();
} }
DoctypeNodeTypeId | DoctypeNodeTypeId |
@ -1619,7 +1582,6 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#concept-node-replace // http://dom.spec.whatwg.org/#concept-node-replace
fn ReplaceChild(&mut self, node: &mut JSRef<Node>, child: &mut JSRef<Node>) -> Fallible<Temporary<Node>> { fn ReplaceChild(&mut self, node: &mut JSRef<Node>, child: &mut JSRef<Node>) -> Fallible<Temporary<Node>> {
let roots = RootCollection::new();
// Step 1. // Step 1.
match self.type_id() { match self.type_id() {
@ -1714,14 +1676,14 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
} }
// Step 7-8. // Step 7-8.
let next_sibling = child.next_sibling().map(|node| (*node.root(&roots)).clone()); let next_sibling = child.next_sibling().map(|node| (*node.root()).clone());
let reference_child = match next_sibling { let reference_child = match next_sibling {
Some(ref sibling) if sibling == node => node.next_sibling().map(|node| (*node.root(&roots)).clone()), Some(ref sibling) if sibling == node => node.next_sibling().map(|node| (*node.root()).clone()),
_ => next_sibling _ => next_sibling
}; };
// Step 9. // Step 9.
let document = document_from_node(self).root(&roots); let document = document_from_node(self).root();
Node::adopt(node, &*document); Node::adopt(node, &*document);
{ {
@ -1755,7 +1717,6 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#dom-node-normalize // http://dom.spec.whatwg.org/#dom-node-normalize
fn Normalize(&mut self) { fn Normalize(&mut self) {
let roots = RootCollection::new();
let mut prev_text = None; let mut prev_text = None;
for mut child in self.children() { for mut child in self.children() {
if child.is_text() { if child.is_text() {
@ -1818,12 +1779,11 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
characterdata.get().data == other_characterdata.get().data characterdata.get().data == other_characterdata.get().data
} }
fn is_equal_element_attrs(node: &JSRef<Node>, other: &JSRef<Node>) -> bool { fn is_equal_element_attrs(node: &JSRef<Node>, other: &JSRef<Node>) -> bool {
let roots = RootCollection::new();
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap(); let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
let other_element: &JSRef<Element> = ElementCast::to_ref(other).unwrap(); let other_element: &JSRef<Element> = ElementCast::to_ref(other).unwrap();
assert!(element.get().attrs.len() == other_element.get().attrs.len()); assert!(element.get().attrs.len() == other_element.get().attrs.len());
element.get().attrs.iter().map(|attr| attr.root(&roots)).all(|attr| { element.get().attrs.iter().map(|attr| attr.root()).all(|attr| {
other_element.get().attrs.iter().map(|attr| attr.root(&roots)).any(|other_attr| { other_element.get().attrs.iter().map(|attr| attr.root()).any(|other_attr| {
(attr.namespace == other_attr.namespace) && (attr.namespace == other_attr.namespace) &&
(attr.local_name == other_attr.local_name) && (attr.local_name == other_attr.local_name) &&
(attr.value == other_attr.value) (attr.value == other_attr.value)
@ -1868,7 +1828,6 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
// http://dom.spec.whatwg.org/#dom-node-comparedocumentposition // http://dom.spec.whatwg.org/#dom-node-comparedocumentposition
fn CompareDocumentPosition(&self, other: &JSRef<Node>) -> u16 { fn CompareDocumentPosition(&self, other: &JSRef<Node>) -> u16 {
let roots = RootCollection::new();
if self == other { if self == other {
// step 2. // step 2.
0 0
@ -1907,7 +1866,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
NodeConstants::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC; NodeConstants::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
} }
for child in lastself.traverse_preorder(&roots) { for child in lastself.traverse_preorder() {
if &child == other { if &child == other {
// step 6. // step 6.
return NodeConstants::DOCUMENT_POSITION_PRECEDING; return NodeConstants::DOCUMENT_POSITION_PRECEDING;
@ -1965,8 +1924,7 @@ pub fn document_from_node<T: NodeBase>(derived: &JSRef<T>) -> Temporary<Document
} }
pub fn window_from_node<T: NodeBase>(derived: &JSRef<T>) -> Temporary<Window> { pub fn window_from_node<T: NodeBase>(derived: &JSRef<T>) -> Temporary<Window> {
let roots = RootCollection::new(); let document = document_from_node(derived).root();
let document = document_from_node(derived).root(&roots);
Temporary::new(document.deref().window.clone()) Temporary::new(document.deref().window.clone())
} }

8
src/components/script/dom/nodelist.rs
View file

@ -3,7 +3,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::BindingDeclarations::NodeListBinding; use dom::bindings::codegen::BindingDeclarations::NodeListBinding;
use dom::bindings::js::{JS, JSRef, Temporary, RootCollection}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::node::{Node, NodeHelpers}; use dom::node::{Node, NodeHelpers};
use dom::window::Window; use dom::window::Window;
@ -54,23 +54,21 @@ pub trait NodeListMethods {
impl<'a> NodeListMethods for JSRef<'a, NodeList> { impl<'a> NodeListMethods for JSRef<'a, NodeList> {
fn Length(&self) -> u32 { fn Length(&self) -> u32 {
let roots = RootCollection::new();
match self.list_type { match self.list_type {
Simple(ref elems) => elems.len() as u32, Simple(ref elems) => elems.len() as u32,
Children(ref node) => { Children(ref node) => {
let node = node.root(&roots); let node = node.root();
node.deref().children().len() as u32 node.deref().children().len() as u32
} }
} }
} }
fn Item(&self, index: u32) -> Option<Temporary<Node>> { fn Item(&self, index: u32) -> Option<Temporary<Node>> {
let roots = RootCollection::new();
match self.list_type { match self.list_type {
_ if index >= self.Length() => None, _ if index >= self.Length() => None,
Simple(ref elems) => Some(Temporary::new(elems.get(index as uint).clone())), Simple(ref elems) => Some(Temporary::new(elems.get(index as uint).clone())),
Children(ref node) => { Children(ref node) => {
let node = node.root(&roots); let node = node.root();
node.deref().children().nth(index as uint) node.deref().children().nth(index as uint)
.map(|child| Temporary::new_rooted(&child)) .map(|child| Temporary::new_rooted(&child))
} }

8
src/components/script/dom/testbinding.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::codegen::BindingDeclarations::TestBindingBinding; use dom::bindings::codegen::BindingDeclarations::TestBindingBinding;
use dom::bindings::codegen::UnionTypes::HTMLElementOrLong; use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
use self::TestBindingBinding::TestEnum; use self::TestBindingBinding::TestEnum;
@ -232,8 +232,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn EnumAttribute(&self) -> TestEnum { _empty } fn EnumAttribute(&self) -> TestEnum { _empty }
fn SetEnumAttribute(&self, _: TestEnum) {} fn SetEnumAttribute(&self, _: TestEnum) {}
fn InterfaceAttribute(&self) -> Temporary<Blob> { fn InterfaceAttribute(&self) -> Temporary<Blob> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
Blob::new(&*window) Blob::new(&*window)
} }
fn SetInterfaceAttribute(&self, _: &JSRef<Blob>) {} fn SetInterfaceAttribute(&self, _: &JSRef<Blob>) {}
@ -268,8 +267,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn SetStringAttributeNullable(&self, _: Option<DOMString>) {} fn SetStringAttributeNullable(&self, _: Option<DOMString>) {}
fn GetEnumAttributeNullable(&self) -> Option<TestEnum> { Some(_empty) } fn GetEnumAttributeNullable(&self) -> Option<TestEnum> { Some(_empty) }
fn GetInterfaceAttributeNullable(&self) -> Option<Temporary<Blob>> { fn GetInterfaceAttributeNullable(&self) -> Option<Temporary<Blob>> {
let roots = RootCollection::new(); let window = self.window.root();
let window = self.window.root(&roots);
Some(Blob::new(&(*window))) Some(Blob::new(&(*window)))
} }
fn SetInterfaceAttributeNullable(&self, _: Option<JSRef<Blob>>) {} fn SetInterfaceAttributeNullable(&self, _: Option<JSRef<Blob>>) {}

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::TextBinding; use dom::bindings::codegen::BindingDeclarations::TextBinding;
use dom::bindings::codegen::InheritTypes::TextDerived; use dom::bindings::codegen::InheritTypes::TextDerived;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::characterdata::CharacterData; use dom::characterdata::CharacterData;
use dom::document::Document; use dom::document::Document;
@ -41,8 +41,7 @@ impl Text {
} }
pub fn Constructor(owner: &JSRef<Window>, text: DOMString) -> Fallible<Temporary<Text>> { pub fn Constructor(owner: &JSRef<Window>, text: DOMString) -> Fallible<Temporary<Text>> {
let roots = RootCollection::new(); let document = owner.Document().root();
let document = owner.Document().root(&roots);
Ok(Text::new(text.clone(), &*document)) Ok(Text::new(text.clone(), &*document))
} }
} }

7
src/components/script/dom/uievent.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::UIEventBinding; use dom::bindings::codegen::BindingDeclarations::UIEventBinding;
use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived}; use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived};
use dom::bindings::js::{JS, JSRef, RootCollection, RootedReference, Temporary}; use dom::bindings::js::{JS, JSRef, RootedReference, Temporary};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventMethods, EventTypeId, UIEventTypeId}; use dom::event::{Event, EventMethods, EventTypeId, UIEventTypeId};
@ -45,9 +45,8 @@ impl UIEvent {
pub fn Constructor(owner: &JSRef<Window>, pub fn Constructor(owner: &JSRef<Window>,
type_: DOMString, type_: DOMString,
init: &UIEventBinding::UIEventInit) -> Fallible<Temporary<UIEvent>> { init: &UIEventBinding::UIEventInit) -> Fallible<Temporary<UIEvent>> {
let roots = RootCollection::new(); let mut ev = UIEvent::new(owner).root();
let mut ev = UIEvent::new(owner).root(&roots); let view = init.view.as_ref().map(|view| view.root());
let view = init.view.as_ref().map(|view| view.root(&roots));
ev.InitUIEvent(type_, init.parent.bubbles, init.parent.cancelable, ev.InitUIEvent(type_, init.parent.bubbles, init.parent.cancelable,
view.root_ref(), init.detail); view.root_ref(), init.detail);
Ok(Temporary::new_rooted(&*ev)) Ok(Temporary::new_rooted(&*ev))

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

@ -5,7 +5,7 @@
use dom::attr::AttrMethods; use dom::attr::AttrMethods;
use dom::bindings::codegen::InheritTypes::{NodeBase, NodeCast, TextCast, ElementCast}; use dom::bindings::codegen::InheritTypes::{NodeBase, NodeCast, TextCast, ElementCast};
use dom::bindings::codegen::InheritTypes::HTMLIFrameElementCast; use dom::bindings::codegen::InheritTypes::HTMLIFrameElementCast;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, OptionalRootable, Root}; use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable, Root};
use dom::bindings::utils::Reflectable; use dom::bindings::utils::Reflectable;
use dom::document::{Document, DocumentHelpers}; use dom::document::{Document, DocumentHelpers};
use dom::element::{AttributeHandlers, HTMLLinkElementTypeId, HTMLIFrameElementTypeId}; use dom::element::{AttributeHandlers, HTMLLinkElementTypeId, HTMLIFrameElementTypeId};
@ -76,21 +76,17 @@ pub struct HtmlParserResult {
} }
trait NodeWrapping<T> { trait NodeWrapping<T> {
unsafe fn to_hubbub_node(&self, roots: &RootCollection) -> hubbub::NodeDataPtr; unsafe fn to_hubbub_node(&self) -> hubbub::NodeDataPtr;
} }
impl<'a, T: NodeBase+Reflectable> NodeWrapping<T> for JSRef<'a, T> { impl<'a, T: NodeBase+Reflectable> NodeWrapping<T> for JSRef<'a, T> {
unsafe fn to_hubbub_node(&self, roots: &RootCollection) -> hubbub::NodeDataPtr { unsafe fn to_hubbub_node(&self) -> hubbub::NodeDataPtr {
roots.root_raw(self.reflector().get_jsobject());
cast::transmute(self.get()) cast::transmute(self.get())
} }
} }
unsafe fn from_hubbub_node<T: Reflectable>(n: hubbub::NodeDataPtr, unsafe fn from_hubbub_node<T: Reflectable>(n: hubbub::NodeDataPtr) -> Temporary<T> {
roots: Option<&RootCollection>) -> Temporary<T> { Temporary::new(JS::from_raw(cast::transmute(n)))
let js = JS::from_raw(cast::transmute(n));
let _ = roots.map(|roots| roots.unroot_raw(js.reflector().get_jsobject()));
Temporary::new(js)
} }
/** /**
@ -297,9 +293,8 @@ pub fn parse_html(page: &Page,
let mut parser = hubbub::Parser("UTF-8", false); let mut parser = hubbub::Parser("UTF-8", false);
debug!("created parser"); debug!("created parser");
let roots = RootCollection::new();
parser.set_document_node(unsafe { document.to_hubbub_node(&roots) }); parser.set_document_node(unsafe { document.to_hubbub_node() });
parser.enable_scripting(true); parser.enable_scripting(true);
parser.enable_styling(true); parser.enable_styling(true);
@ -315,9 +310,9 @@ pub fn parse_html(page: &Page,
// NOTE: tmp vars are workaround for lifetime issues. Both required. // NOTE: tmp vars are workaround for lifetime issues. Both required.
let tmp_borrow = doc_cell.borrow(); let tmp_borrow = doc_cell.borrow();
let tmp = &*tmp_borrow; let tmp = &*tmp_borrow;
let comment = Comment::new(data, *tmp).root(&roots); let comment = Comment::new(data, *tmp).root();
let comment: &JSRef<Node> = NodeCast::from_ref(&*comment); let comment: &JSRef<Node> = NodeCast::from_ref(&*comment);
unsafe { comment.to_hubbub_node(&roots) } unsafe { comment.to_hubbub_node() }
}, },
create_doctype: |doctype: ~hubbub::Doctype| { create_doctype: |doctype: ~hubbub::Doctype| {
debug!("create doctype"); debug!("create doctype");
@ -328,9 +323,9 @@ pub fn parse_html(page: &Page,
// NOTE: tmp vars are workaround for lifetime issues. Both required. // NOTE: tmp vars are workaround for lifetime issues. Both required.
let tmp_borrow = doc_cell.borrow(); let tmp_borrow = doc_cell.borrow();
let tmp = &*tmp_borrow; let tmp = &*tmp_borrow;
let doctype_node = DocumentType::new(name, public_id, system_id, *tmp).root(&roots); let doctype_node = DocumentType::new(name, public_id, system_id, *tmp).root();
unsafe { unsafe {
doctype_node.deref().to_hubbub_node(&roots) doctype_node.deref().to_hubbub_node()
} }
}, },
create_element: |tag: ~hubbub::Tag| { create_element: |tag: ~hubbub::Tag| {
@ -338,7 +333,7 @@ pub fn parse_html(page: &Page,
// NOTE: tmp vars are workaround for lifetime issues. Both required. // NOTE: tmp vars are workaround for lifetime issues. Both required.
let tmp_borrow = doc_cell.borrow(); let tmp_borrow = doc_cell.borrow();
let tmp = &*tmp_borrow; let tmp = &*tmp_borrow;
let mut element = build_element_from_tag(tag.name.clone(), *tmp).root(&roots); let mut element = build_element_from_tag(tag.name.clone(), *tmp).root();
debug!("-- attach attrs"); debug!("-- attach attrs");
for attr in tag.attributes.iter() { for attr in tag.attributes.iter() {
@ -351,15 +346,15 @@ pub fn parse_html(page: &Page,
//FIXME: workaround for https://github.com/mozilla/rust/issues/13246; //FIXME: workaround for https://github.com/mozilla/rust/issues/13246;
// we get unrooting order failures if these are inside the match. // we get unrooting order failures if these are inside the match.
let rel = { let rel = {
let rel = element.get_attribute(Null, "rel").root(&roots); let rel = element.get_attribute(Null, "rel").root();
rel.map(|a| a.deref().Value()) rel.map(|a| a.deref().Value())
}; };
let href = { let href = {
let href= element.get_attribute(Null, "href").root(&roots); let href= element.get_attribute(Null, "href").root();
href.map(|a| a.deref().Value()) href.map(|a| a.deref().Value())
}; };
let src_opt = { let src_opt = {
let src_opt = element.get_attribute(Null, "src").root(&roots); let src_opt = element.get_attribute(Null, "src").root();
src_opt.map(|a| a.deref().Value()) src_opt.map(|a| a.deref().Value())
}; };
@ -410,23 +405,23 @@ pub fn parse_html(page: &Page,
_ => {} _ => {}
} }
unsafe { element.to_hubbub_node(&roots) } unsafe { element.to_hubbub_node() }
}, },
create_text: |data: ~str| { create_text: |data: ~str| {
debug!("create text"); debug!("create text");
// NOTE: tmp vars are workaround for lifetime issues. Both required. // NOTE: tmp vars are workaround for lifetime issues. Both required.
let tmp_borrow = doc_cell.borrow(); let tmp_borrow = doc_cell.borrow();
let tmp = &*tmp_borrow; let tmp = &*tmp_borrow;
let text = Text::new(data, *tmp).root(&roots); let text = Text::new(data, *tmp).root();
unsafe { text.deref().to_hubbub_node(&roots) } unsafe { text.deref().to_hubbub_node() }
}, },
ref_node: |_| {}, ref_node: |_| {},
unref_node: |_| {}, unref_node: |_| {},
append_child: |parent: hubbub::NodeDataPtr, child: hubbub::NodeDataPtr| { append_child: |parent: hubbub::NodeDataPtr, child: hubbub::NodeDataPtr| {
unsafe { unsafe {
debug!("append child {:x} {:x}", parent, child); debug!("append child {:x} {:x}", parent, child);
let mut child = from_hubbub_node(child, Some(&roots)).root(&roots); let mut child = from_hubbub_node(child).root();
let mut parent: Root<Node> = from_hubbub_node(parent, None).root(&roots); let mut parent: Root<Node> = from_hubbub_node(parent).root();
assert!(parent.AppendChild(&mut *child).is_ok()); assert!(parent.AppendChild(&mut *child).is_ok());
} }
child child
@ -478,8 +473,8 @@ pub fn parse_html(page: &Page,
}, },
complete_script: |script| { complete_script: |script| {
unsafe { unsafe {
let script: &JSRef<Element> = &*from_hubbub_node(script, None).root(&roots); let script: &JSRef<Element> = &*from_hubbub_node(script).root();
match script.get_attribute(Null, "src").root(&roots) { match script.get_attribute(Null, "src").root() {
Some(src) => { Some(src) => {
debug!("found script: {:s}", src.deref().Value()); debug!("found script: {:s}", src.deref().Value());
let new_url = parse_url(src.get().value_ref(), Some(url3.clone())); let new_url = parse_url(src.get().value_ref(), Some(url3.clone()));

61
src/components/script/script_task.rs
View file

@ -278,12 +278,11 @@ impl Page {
/// Adds the given damage. /// Adds the given damage.
pub fn damage(&self, level: DocumentDamageLevel) { pub fn damage(&self, level: DocumentDamageLevel) {
let roots = RootCollection::new();
let root = match *self.frame() { let root = match *self.frame() {
None => return, None => return,
Some(ref frame) => frame.document.root(&roots).GetDocumentElement() Some(ref frame) => frame.document.root().GetDocumentElement()
}; };
match root.root(&roots) { match root.root() {
None => {}, None => {},
Some(root) => { Some(root) => {
let root: &JSRef<Node> = NodeCast::from_ref(&*root); let root: &JSRef<Node> = NodeCast::from_ref(&*root);
@ -358,16 +357,15 @@ impl Page {
goal: ReflowGoal, goal: ReflowGoal,
script_chan: ScriptChan, script_chan: ScriptChan,
compositor: &ScriptListener) { compositor: &ScriptListener) {
let roots = RootCollection::new();
let root = match *self.frame() { let root = match *self.frame() {
None => return, None => return,
Some(ref frame) => { Some(ref frame) => {
frame.document.root(&roots).GetDocumentElement() frame.document.root().GetDocumentElement()
} }
}; };
match root.root(&roots) { match root.root() {
None => {}, None => {},
Some(root) => { Some(root) => {
debug!("script: performing reflow for goal {:?}", goal); debug!("script: performing reflow for goal {:?}", goal);
@ -411,17 +409,16 @@ impl Page {
} }
fn find_fragment_node(&self, fragid: ~str) -> Option<Temporary<Element>> { fn find_fragment_node(&self, fragid: ~str) -> Option<Temporary<Element>> {
let roots = RootCollection::new(); let document = self.frame().get_ref().document.root();
let document = self.frame().get_ref().document.root(&roots);
match document.deref().GetElementById(fragid.to_owned()) { match document.deref().GetElementById(fragid.to_owned()) {
Some(node) => Some(node), Some(node) => Some(node),
None => { None => {
let doc_node: &JSRef<Node> = NodeCast::from_ref(&*document); let doc_node: &JSRef<Node> = NodeCast::from_ref(&*document);
let mut anchors = doc_node.traverse_preorder(&roots) let mut anchors = doc_node.traverse_preorder()
.filter(|node| node.is_anchor_element()); .filter(|node| node.is_anchor_element());
anchors.find(|node| { anchors.find(|node| {
let elem: &JSRef<Element> = ElementCast::to_ref(node).unwrap(); let elem: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
elem.get_attribute(Null, "name").root(&roots).map_or(false, |attr| { elem.get_attribute(Null, "name").root().map_or(false, |attr| {
attr.get().value_ref() == fragid attr.get().value_ref() == fragid
}) })
}).map(|node| Temporary::new_rooted(ElementCast::to_ref(&node).unwrap())) }).map(|node| Temporary::new_rooted(ElementCast::to_ref(&node).unwrap()))
@ -450,10 +447,9 @@ impl Page {
} }
pub fn hit_test(&self, point: &Point2D<f32>) -> Option<UntrustedNodeAddress> { pub fn hit_test(&self, point: &Point2D<f32>) -> Option<UntrustedNodeAddress> {
let roots = RootCollection::new();
let frame = self.frame(); let frame = self.frame();
let document = frame.get_ref().document.root(&roots); let document = frame.get_ref().document.root();
let root = document.deref().GetDocumentElement().root(&roots); let root = document.deref().GetDocumentElement().root();
if root.is_none() { if root.is_none() {
return None; return None;
} }
@ -473,10 +469,9 @@ impl Page {
} }
pub fn get_nodes_under_mouse(&self, point: &Point2D<f32>) -> Option<Vec<UntrustedNodeAddress>> { pub fn get_nodes_under_mouse(&self, point: &Point2D<f32>) -> Option<Vec<UntrustedNodeAddress>> {
let roots = RootCollection::new();
let frame = self.frame(); let frame = self.frame();
let document = frame.get_ref().document.root(&roots); let document = frame.get_ref().document.root();
let root = document.deref().GetDocumentElement().root(&roots); let root = document.deref().GetDocumentElement().root();
if root.is_none() { if root.is_none() {
return None; return None;
} }
@ -763,13 +758,12 @@ impl ScriptTask {
/// Handles a timer that fired. /// Handles a timer that fired.
fn handle_fire_timer_msg(&self, id: PipelineId, timer_id: TimerId) { fn handle_fire_timer_msg(&self, id: PipelineId, timer_id: TimerId) {
let roots = RootCollection::new();
let mut page_tree = self.page_tree.borrow_mut(); let mut page_tree = self.page_tree.borrow_mut();
let page = page_tree.find(id).expect("ScriptTask: received fire timer msg for a let page = page_tree.find(id).expect("ScriptTask: received fire timer msg for a
pipeline ID not associated with this script task. This is a bug.").page(); pipeline ID not associated with this script task. This is a bug.").page();
let frame = page.frame(); let frame = page.frame();
let mut window = frame.get_ref().window.root(&roots); let mut window = frame.get_ref().window.root();
let is_interval; let is_interval;
match window.get().active_timers.find(&timer_id) { match window.get().active_timers.find(&timer_id) {
@ -880,7 +874,6 @@ impl ScriptTask {
fn load(&self, pipeline_id: PipelineId, url: Url) { fn load(&self, pipeline_id: PipelineId, url: Url) {
debug!("ScriptTask: loading {:?} on page {:?}", url, pipeline_id); debug!("ScriptTask: loading {:?} on page {:?}", url, pipeline_id);
let roots = RootCollection::new();
let mut page_tree = self.page_tree.borrow_mut(); let mut page_tree = self.page_tree.borrow_mut();
let page_tree = page_tree.find(pipeline_id).expect("ScriptTask: received a load let page_tree = page_tree.find(pipeline_id).expect("ScriptTask: received a load
@ -907,9 +900,9 @@ impl ScriptTask {
page_tree.page.clone(), page_tree.page.clone(),
self.chan.clone(), self.chan.clone(),
self.compositor.dup(), self.compositor.dup(),
self.image_cache_task.clone()).root(&roots); self.image_cache_task.clone()).root();
page.initialize_js_info(cx.clone(), window.reflector().get_jsobject()); page.initialize_js_info(cx.clone(), window.reflector().get_jsobject());
let mut document = Document::new(&*window, Some(url.clone()), HTMLDocument, None).root(&roots); let mut document = Document::new(&*window, Some(url.clone()), HTMLDocument, None).root();
window.get_mut().init_browser_context(&*document); window.get_mut().init_browser_context(&*document);
{ {
@ -1010,7 +1003,7 @@ impl ScriptTask {
// We have no concept of a document loader right now, so just dispatch the // We have no concept of a document loader right now, so just dispatch the
// "load" event as soon as we've finished executing all scripts parsed during // "load" event as soon as we've finished executing all scripts parsed during
// the initial load. // the initial load.
let mut event = Event::new(&*window).root(&roots); let mut event = Event::new(&*window).root();
event.InitEvent(~"load", false, false); event.InitEvent(~"load", false, false);
let doctarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*document); let doctarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*document);
let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window); let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
@ -1048,7 +1041,6 @@ impl ScriptTask {
match event { match event {
ResizeEvent(new_width, new_height) => { ResizeEvent(new_width, new_height) => {
let roots = RootCollection::new();
debug!("script got resize event: {:u}, {:u}", new_width, new_height); debug!("script got resize event: {:u}, {:u}", new_width, new_height);
let window = { let window = {
@ -1066,7 +1058,7 @@ impl ScriptTask {
} }
let mut fragment_node = page.fragment_node.deref().borrow_mut(); let mut fragment_node = page.fragment_node.deref().borrow_mut();
match fragment_node.take().map(|node| node.root(&roots)) { match fragment_node.take().map(|node| node.root()) {
Some(node) => self.scroll_fragment_point(pipeline_id, &*node), Some(node) => self.scroll_fragment_point(pipeline_id, &*node),
None => {} None => {}
} }
@ -1074,11 +1066,11 @@ impl ScriptTask {
frame.as_ref().map(|frame| Temporary::new(frame.window.clone())) frame.as_ref().map(|frame| Temporary::new(frame.window.clone()))
}; };
match window.root(&roots) { match window.root() {
Some(mut window) => { Some(mut window) => {
// http://dev.w3.org/csswg/cssom-view/#resizing-viewports // http://dev.w3.org/csswg/cssom-view/#resizing-viewports
// https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize
let mut uievent = UIEvent::new(&*window).root(&roots); let mut uievent = UIEvent::new(&*window).root();
uievent.InitUIEvent(~"resize", false, false, uievent.InitUIEvent(~"resize", false, false,
Some((*window).clone()), 0i32); Some((*window).clone()), 0i32);
let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *uievent); let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *uievent);
@ -1104,7 +1096,6 @@ impl ScriptTask {
} }
ClickEvent(_button, point) => { ClickEvent(_button, point) => {
let roots = RootCollection::new();
debug!("ClickEvent: clicked at {:?}", point); debug!("ClickEvent: clicked at {:?}", point);
let mut page_tree = self.page_tree.borrow_mut(); let mut page_tree = self.page_tree.borrow_mut();
let page = get_page(&mut *page_tree, pipeline_id); let page = get_page(&mut *page_tree, pipeline_id);
@ -1113,14 +1104,14 @@ impl ScriptTask {
debug!("node address is {:?}", node_address); debug!("node address is {:?}", node_address);
let mut node = let mut node =
node::from_untrusted_node_address(self.js_runtime.deref().ptr, node::from_untrusted_node_address(self.js_runtime.deref().ptr,
node_address).root(&roots); node_address).root();
debug!("clicked on {:s}", node.deref().debug_str()); debug!("clicked on {:s}", node.deref().debug_str());
// Traverse node generations until a node that is an element is // Traverse node generations until a node that is an element is
// found. // found.
while !node.deref().is_element() { while !node.deref().is_element() {
match node.deref().parent_node() { match node.deref().parent_node() {
Some(parent) => node = parent.root(&roots), Some(parent) => node = parent.root(),
None => break, None => break,
} }
} }
@ -1139,7 +1130,6 @@ impl ScriptTask {
MouseDownEvent(..) => {} MouseDownEvent(..) => {}
MouseUpEvent(..) => {} MouseUpEvent(..) => {}
MouseMoveEvent(point) => { MouseMoveEvent(point) => {
let roots = RootCollection::new();
let mut page_tree = self.page_tree.borrow_mut(); let mut page_tree = self.page_tree.borrow_mut();
let page = get_page(&mut *page_tree, pipeline_id); let page = get_page(&mut *page_tree, pipeline_id);
match page.get_nodes_under_mouse(&point) { match page.get_nodes_under_mouse(&point) {
@ -1152,7 +1142,7 @@ impl ScriptTask {
match *mouse_over_targets { match *mouse_over_targets {
Some(ref mut mouse_over_targets) => { Some(ref mut mouse_over_targets) => {
for node in mouse_over_targets.mut_iter() { for node in mouse_over_targets.mut_iter() {
let mut node = node.root(&roots); let mut node = node.root();
node.set_hover_state(false); node.set_hover_state(false);
} }
} }
@ -1162,12 +1152,12 @@ impl ScriptTask {
for node_address in node_address.iter() { for node_address in node_address.iter() {
let mut node = let mut node =
node::from_untrusted_node_address( node::from_untrusted_node_address(
self.js_runtime.deref().ptr, *node_address).root(&roots); self.js_runtime.deref().ptr, *node_address).root();
// Traverse node generations until a node that is an element is // Traverse node generations until a node that is an element is
// found. // found.
while !node.is_element() { while !node.is_element() {
match node.parent_node() { match node.parent_node() {
Some(parent) => node = parent.root(&roots), Some(parent) => node = parent.root(),
None => break, None => break,
} }
} }
@ -1211,10 +1201,9 @@ impl ScriptTask {
} }
fn load_url_from_element(&self, page: &Page, element: &JSRef<Element>) { fn load_url_from_element(&self, page: &Page, element: &JSRef<Element>) {
let roots = RootCollection::new();
// if the node's element is "a," load url from href attr // if the node's element is "a," load url from href attr
let attr = element.get_attribute(Null, "href"); let attr = element.get_attribute(Null, "href");
for href in attr.root(&roots).iter() { for href in attr.root().iter() {
debug!("ScriptTask: clicked on link to {:s}", href.Value()); debug!("ScriptTask: clicked on link to {:s}", href.Value());
let click_frag = href.get().value_ref().starts_with("#"); let click_frag = href.get().value_ref().starts_with("#");
let base_url = Some(page.get_url()); let base_url = Some(page.get_url());
@ -1222,7 +1211,7 @@ impl ScriptTask {
let url = parse_url(href.get().value_ref(), base_url); let url = parse_url(href.get().value_ref(), base_url);
if click_frag { if click_frag {
match page.find_fragment_node(url.fragment.unwrap()).root(&roots) { match page.find_fragment_node(url.fragment.unwrap()).root() {
Some(node) => self.scroll_fragment_point(page.id, &*node), Some(node) => self.scroll_fragment_point(page.id, &*node),
None => {} None => {}
} }