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

Turn on GC all the time. Fix rooting errors during parsing and storing timers. Fix borrow errors during tracing.

Browse source
This commit is contained in:
Josh Matthews 2014-03-28 10:17:56 -04:00
parent 4051a8096d
commit ffdc3f5b32
109 changed files with 1567 additions and 996 deletions
Download patch file Download diff file Expand all files Collapse all files

1
configure vendored
View file

@ -697,6 +697,7 @@ do
CONFIGURE_ARGS="${CONFIGURE_ARGS} --with-android-ndk=${CFG_ANDROID_NDK_PATH}" CONFIGURE_ARGS="${CONFIGURE_ARGS} --with-android-ndk=${CFG_ANDROID_NDK_PATH}"
CONFIGURE_ARGS="${CONFIGURE_ARGS} --with-android-toolchain=${CFG_ANDROID_CROSS_PATH}" CONFIGURE_ARGS="${CONFIGURE_ARGS} --with-android-toolchain=${CFG_ANDROID_CROSS_PATH}"
fi fi
CONFIGURE_ARGS="${CONFIGURE_ARGS} --enable-gczeal"
;; ;;
support/skia/skia) support/skia/skia)
# Right now the skia configure script actually ignores --enable-debug and the # Right now the skia configure script actually ignores --enable-debug and the

4
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; use dom::bindings::js::{JS, JSRef};
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;
@ -57,7 +57,7 @@ impl Attr {
} }
} }
pub fn new(window: &JS<Window>, local_name: DOMString, value: DOMString, pub fn new(window: &JSRef<Window>, local_name: DOMString, value: DOMString,
name: DOMString, namespace: Namespace, name: DOMString, namespace: Namespace,
prefix: Option<DOMString>, owner: JS<Element>) -> JS<Attr> { prefix: Option<DOMString>, owner: JS<Element>) -> JS<Attr> {
let attr = Attr::new_inherited(local_name, value, name, namespace, prefix, owner); let attr = Attr::new_inherited(local_name, value, name, namespace, prefix, owner);

6
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; use dom::bindings::js::{JS, JSRef};
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;
@ -25,8 +25,8 @@ impl AttrList {
} }
} }
pub fn new(window: &JS<Window>, elem: &JS<Element>) -> JS<AttrList> { pub fn new(window: &JSRef<Window>, elem: &JSRef<Element>) -> JS<AttrList> {
reflect_dom_object(~AttrList::new_inherited(window.clone(), elem.clone()), reflect_dom_object(~AttrList::new_inherited(window.unrooted(), elem.unrooted()),
window, AttrListBinding::Wrap) window, AttrListBinding::Wrap)
} }

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

@ -281,6 +281,7 @@ class CGMethodCall(CGThing):
isDefinitelyObject=True), isDefinitelyObject=True),
{ {
"declName" : "arg%d" % distinguishingIndex, "declName" : "arg%d" % distinguishingIndex,
"simpleDeclName" : "arg%d" % distinguishingIndex,
"holderName" : ("arg%d" % distinguishingIndex) + "_holder", "holderName" : ("arg%d" % distinguishingIndex) + "_holder",
"val" : distinguishingArg "val" : distinguishingArg
}) })
@ -551,12 +552,21 @@ def getJSToNativeConversionTemplate(type, descriptorProvider, failureCode=None,
templateBody += ( templateBody += (
"} else {\n" + "} else {\n" +
CGIndenter(onFailureNotAnObject(failureCode)).define() + CGIndenter(onFailureNotAnObject(failureCode)).define() +
"}") "}\n")
if type.nullable(): if type.nullable():
templateBody = handleDefaultNull(templateBody, "None") templateBody = handleDefaultNull(templateBody, "None")
else: else:
assert(defaultValue is None) assert(defaultValue is None)
#if type.isGeckoInterface() and not type.unroll().inner.isCallback():
# if type.nullable() or isOptional:
#
# else:
#
# templateBody = CGList([CGGeneric(templateBody),
# CGGeneric("\n"),
# CGGeneric(rootBody)]).define()
return templateBody return templateBody
assert not (isEnforceRange and isClamp) # These are mutually exclusive assert not (isEnforceRange and isClamp) # These are mutually exclusive
@ -888,6 +898,18 @@ def instantiateJSToNativeConversionTemplate(templateTuple, replacements,
# Add an empty CGGeneric to get an extra newline after the argument # Add an empty CGGeneric to get an extra newline after the argument
# conversion. # conversion.
result.append(CGGeneric("")) result.append(CGGeneric(""))
type = declType.define() if declType else None
if type and 'JS<' in type:
if dealWithOptional or 'Option<' in type:
rootBody = """let ${simpleDeclName} = ${declName}.as_ref().map(|inner| {
inner.root(&roots) //second root code
});"""
else:
rootBody = "let ${simpleDeclName} = ${declName}.root(&roots); //third root code"
result.append(CGGeneric(string.Template(rootBody).substitute(replacements)))
result.append(CGGeneric(""))
return result; return result;
def convertConstIDLValueToJSVal(value): def convertConstIDLValueToJSVal(value):
@ -929,6 +951,7 @@ class CGArgumentConverter(CGThing):
} }
self.replacementVariables = { self.replacementVariables = {
"declName" : "arg%d" % index, "declName" : "arg%d" % index,
"simpleDeclName" : "arg%d" % index,
"holderName" : ("arg%d" % index) + "_holder" "holderName" : ("arg%d" % index) + "_holder"
} }
self.replacementVariables["val"] = string.Template( self.replacementVariables["val"] = string.Template(
@ -1691,6 +1714,8 @@ class Argument():
A class for outputting the type and name of an argument A class for outputting the type and name of an argument
""" """
def __init__(self, argType, name, default=None, mutable=False): def __init__(self, argType, name, default=None, mutable=False):
if argType and 'JS<' in argType:
argType = argType.replace('JS<', 'JSRef<')
self.argType = argType self.argType = argType
self.name = name self.name = name
self.default = default self.default = default
@ -1763,7 +1788,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 {" if self.unsafe else "" return "\n unsafe {\n let roots = RootCollection::new();\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 ""
@ -1809,7 +1834,7 @@ class CGWrapMethod(CGAbstractMethod):
def __init__(self, descriptor): def __init__(self, descriptor):
assert descriptor.interface.hasInterfacePrototypeObject() assert descriptor.interface.hasInterfacePrototypeObject()
if not descriptor.createGlobal: if not descriptor.createGlobal:
args = [Argument('*JSContext', 'aCx'), Argument('&JS<Window>', 'aScope'), args = [Argument('*JSContext', 'aCx'), Argument('&JSRef<Window>', 'aScope'),
Argument("~" + descriptor.concreteType, 'aObject', mutable=True)] Argument("~" + descriptor.concreteType, 'aObject', mutable=True)]
else: else:
args = [Argument('*JSContext', 'aCx'), args = [Argument('*JSContext', 'aCx'),
@ -2277,7 +2302,12 @@ class CGPerSignatureCall(CGThing):
def getArgc(self): def getArgc(self):
return "argc" return "argc"
def getArguments(self): def getArguments(self):
return [(a, "arg" + str(i)) for (i, a) in enumerate(self.arguments)] def process(arg, i):
argVal = "arg" + str(i)
if arg.type.isGeckoInterface() and not arg.type.unroll().inner.isCallback():
argVal += ".root_ref()"
return argVal
return [(a, process(a, i)) for (i, a) in enumerate(self.arguments)]
def isFallible(self): def isFallible(self):
return not 'infallible' in self.extendedAttributes return not 'infallible' in self.extendedAttributes
@ -2452,8 +2482,10 @@ class CGSpecializedMethod(CGAbstractExternMethod):
argsPre = [] argsPre = []
if name in self.descriptor.needsAbstract: if name in self.descriptor.needsAbstract:
abstractName = re.sub(r'<\w+>', '', self.descriptor.nativeType) abstractName = re.sub(r'<\w+>', '', self.descriptor.nativeType)
extraPre = ' let mut abstract_this = %s::from_raw(this);\n' % abstractName extraPre = """ let mut abstract_this = %s::from_raw(this);
argsPre = ['&mut abstract_this'] let abstract_this = abstract_this.root(&roots);
""" % abstractName
argsPre = ['&mut abstract_this.root_ref()']
return CGWrapper(CGMethodCall(argsPre, nativeName, self.method.isStatic(), return CGWrapper(CGMethodCall(argsPre, nativeName, self.method.isStatic(),
self.descriptor, self.method), self.descriptor, self.method),
pre=extraPre + pre=extraPre +
@ -2480,10 +2512,8 @@ class CGGenericGetter(CGAbstractBindingMethod):
def generate_code(self): def generate_code(self):
return CGIndenter(CGGeneric( return CGIndenter(CGGeneric(
"return with_gc_disabled(cx, || {\n" "let info: *JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, &*vp));\n"
" let info: *JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, &*vp));\n" "return CallJitPropertyOp(info, cx, obj, this.unsafe_get() as *libc::c_void, &*vp);\n"))
" CallJitPropertyOp(info, cx, obj, this.unsafe_get() as *libc::c_void, &*vp)\n"
"});\n"))
class CGSpecializedGetter(CGAbstractExternMethod): class CGSpecializedGetter(CGAbstractExternMethod):
""" """
@ -2509,8 +2539,10 @@ class CGSpecializedGetter(CGAbstractExternMethod):
getter=True)) getter=True))
if name in self.descriptor.needsAbstract: if name in self.descriptor.needsAbstract:
abstractName = re.sub(r'<\w+>', '', self.descriptor.nativeType) abstractName = re.sub(r'<\w+>', '', self.descriptor.nativeType)
extraPre = ' let mut abstract_this = %s::from_raw(this);\n' % abstractName extraPre = """ let mut abstract_this = %s::from_raw(this);
argsPre = ['&mut abstract_this'] let abstract_this = abstract_this.root(&roots);
""" % abstractName
argsPre = ['&mut abstract_this.root_ref()']
if self.attr.type.nullable() or not infallible: if self.attr.type.nullable() or not infallible:
nativeName = "Get" + nativeName nativeName = "Get" + nativeName
return CGWrapper(CGIndenter(CGGetterCall(argsPre, self.attr.type, nativeName, return CGWrapper(CGIndenter(CGGetterCall(argsPre, self.attr.type, nativeName,
@ -2541,10 +2573,7 @@ class CGGenericSetter(CGAbstractBindingMethod):
"let undef = UndefinedValue();\n" "let undef = UndefinedValue();\n"
"let argv: *JSVal = if argc != 0 { JS_ARGV(cx, vp as *JSVal) } else { &undef as *JSVal };\n" "let argv: *JSVal = if argc != 0 { JS_ARGV(cx, vp as *JSVal) } else { &undef as *JSVal };\n"
"let info: *JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp as *JSVal));\n" "let info: *JSJitInfo = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp as *JSVal));\n"
"let ok = with_gc_disabled(cx, || {\n" "if CallJitPropertyOp(info, cx, obj, this.unsafe_get() as *libc::c_void, argv) == 0 {\n"
" CallJitPropertyOp(info, cx, obj, this.unsafe_get() as *libc::c_void, argv)\n"
"});\n"
"if ok == 0 {\n"
" return 0;\n" " return 0;\n"
"}\n" "}\n"
"*vp = UndefinedValue();\n" "*vp = UndefinedValue();\n"
@ -2571,8 +2600,10 @@ class CGSpecializedSetter(CGAbstractExternMethod):
extraPre = '' extraPre = ''
if name in self.descriptor.needsAbstract: if name in self.descriptor.needsAbstract:
abstractName = re.sub(r'<\w+>', '', self.descriptor.nativeType) abstractName = re.sub(r'<\w+>', '', self.descriptor.nativeType)
extraPre = ' let mut abstract_this = %s::from_raw(this);\n' % abstractName extraPre = """ let mut abstract_this = %s::from_raw(this);
argsPre = ['&mut abstract_this'] let abstract_this = abstract_this.root(&roots);
""" % abstractName
argsPre = ['&mut abstract_this.root_ref()']
return CGWrapper(CGIndenter(CGSetterCall(argsPre, self.attr.type, nativeName, return CGWrapper(CGIndenter(CGSetterCall(argsPre, self.attr.type, nativeName,
self.descriptor, self.attr)), self.descriptor, self.attr)),
pre=extraPre + pre=extraPre +
@ -3402,6 +3433,7 @@ class CGProxySpecialOperation(CGPerSignatureCall):
treatNullAs=argument.treatNullAs) treatNullAs=argument.treatNullAs)
templateValues = { templateValues = {
"declName": argument.identifier.name, "declName": argument.identifier.name,
"simpleDeclName": argument.identifier.name,
"holderName": argument.identifier.name + "_holder", "holderName": argument.identifier.name + "_holder",
"val": "(*desc).value", "val": "(*desc).value",
"valPtr": "&(*desc).value" "valPtr": "&(*desc).value"
@ -3411,7 +3443,12 @@ class CGProxySpecialOperation(CGPerSignatureCall):
self.cgRoot.prepend(CGGeneric("let mut found = false;")) self.cgRoot.prepend(CGGeneric("let mut found = false;"))
def getArguments(self): def getArguments(self):
args = [(a, a.identifier.name) for a in self.arguments] def process(arg):
argVal = arg.identifier.name
if arg.type.isGeckoInterface() and not arg.type.unroll().inner.isCallback():
argVal += ".root_ref()"
return argVal
args = [(a, process(a)) for a in self.arguments]
if self.idlNode.isGetter(): if self.idlNode.isGetter():
args.append((FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean], args.append((FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean],
self.idlNode), self.idlNode),
@ -3825,11 +3862,13 @@ 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 obj = global.reflector().get_jsobject(); let obj = global.reflector().get_jsobject();
""" """
nativeName = MakeNativeName(self._ctor.identifier.name) nativeName = MakeNativeName(self._ctor.identifier.name)
callGenerator = CGMethodCall(["&global"], nativeName, True, callGenerator = CGMethodCall(["&global.root_ref()"], nativeName, True,
self.descriptor, self._ctor) self.descriptor, self._ctor)
return preamble + callGenerator.define(); return preamble + callGenerator.define();
@ -4067,6 +4106,7 @@ 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"
@ -4266,7 +4306,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', 'dom::bindings::js::{JS, JSRef, RootCollection, RootedReference}',
'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}',
@ -4279,8 +4319,7 @@ class CGBindingRoot(CGThing):
'dom::bindings::utils::{Reflectable}', 'dom::bindings::utils::{Reflectable}',
'dom::bindings::utils::{squirrel_away_unique}', 'dom::bindings::utils::{squirrel_away_unique}',
'dom::bindings::utils::{ThrowingConstructor, unwrap, unwrap_jsmanaged}', 'dom::bindings::utils::{ThrowingConstructor, unwrap, unwrap_jsmanaged}',
'dom::bindings::utils::{VoidVal, with_gc_disabled}', 'dom::bindings::utils::VoidVal',
'dom::bindings::utils::{with_gc_enabled}',
'dom::bindings::utils::get_dictionary_property', 'dom::bindings::utils::get_dictionary_property',
'dom::bindings::trace::JSTraceable', 'dom::bindings::trace::JSTraceable',
'dom::bindings::callback::{CallbackContainer,CallbackInterface}', 'dom::bindings::callback::{CallbackContainer,CallbackInterface}',
@ -5057,11 +5096,8 @@ class CallbackMethod(CallbackMember):
replacements["argc"] = "0" replacements["argc"] = "0"
return string.Template("${getCallable}" return string.Template("${getCallable}"
"let ok = unsafe {\n" "let ok = unsafe {\n"
" //JS_AllowGC(cx); // It's unsafe to enable GC at arbitrary points during Rust execution; leave it disabled\n" " JS_CallFunctionValue(cx, ${thisObj}, callable,\n"
" let ok = JS_CallFunctionValue(cx, ${thisObj}, callable,\n" " ${argc}, ${argv}, &rval)\n"
" ${argc}, ${argv}, &rval);\n"
" //JS_InhibitGC(cx);\n"
" ok\n"
"};\n" "};\n"
"if ok == 0 {\n" "if ok == 0 {\n"
" return${errorReturn};\n" " return${errorReturn};\n"
@ -5209,7 +5245,7 @@ class GlobalGenRoots():
# TODO - Generate the methods we want # TODO - Generate the methods we want
return CGImports(CGRegisterProtos(config), [ return CGImports(CGRegisterProtos(config), [
'dom::bindings::codegen', 'dom::bindings::codegen',
'dom::bindings::js::JS', 'dom::bindings::js::{JS, JSRef}',
'dom::window::Window', 'dom::window::Window',
'script_task::JSPageInfo', 'script_task::JSPageInfo',
]) ])
@ -5241,7 +5277,7 @@ class GlobalGenRoots():
descriptors = config.getDescriptors(register=True, hasInterfaceObject=True) descriptors = config.getDescriptors(register=True, hasInterfaceObject=True)
allprotos = [CGGeneric("#![allow(unused_imports)]\n"), allprotos = [CGGeneric("#![allow(unused_imports)]\n"),
CGGeneric("use dom::types::*;\n"), CGGeneric("use dom::types::*;\n"),
CGGeneric("use dom::bindings::js::JS;\n"), CGGeneric("use dom::bindings::js::{JS, JSRef};\n"),
CGGeneric("use dom::bindings::trace::JSTraceable;\n"), CGGeneric("use dom::bindings::trace::JSTraceable;\n"),
CGGeneric("use serialize::{Encodable, Encoder};\n"), CGGeneric("use serialize::{Encodable, Encoder};\n"),
CGGeneric("use js::jsapi::JSTracer;\n\n")] CGGeneric("use js::jsapi::JSTracer;\n\n")]
@ -5286,6 +5322,14 @@ class GlobalGenRoots():
assert!(base.get().${checkFn}()); assert!(base.get().${checkFn}());
base.clone().transmute() base.clone().transmute()
} }
fn from_ref<'a, 'b, T: ${fromBound}>(derived: &'a JSRef<'b, T>) -> &'a JSRef<'b, Self> {
unsafe { derived.transmute() }
}
fn from_mut_ref<'a, 'b, T: ${fromBound}>(derived: &'a mut JSRef<'b, T>) -> &'a mut JSRef<'b, Self> {
unsafe { derived.transmute_mut() }
}
} }
''').substitute({'checkFn': 'is_' + name.lower(), ''').substitute({'checkFn': 'is_' + name.lower(),
'castTraitName': name + 'Cast', 'castTraitName': name + 'Cast',

20
src/components/script/dom/bindings/conversions.rs
View file

@ -2,9 +2,9 @@
* 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; use dom::bindings::js::{JS, JSRef};
use dom::bindings::str::ByteString; use dom::bindings::str::ByteString;
use dom::bindings::utils::Reflectable; use dom::bindings::utils::{Reflectable, Reflector};
use dom::bindings::utils::jsstring_to_str; use dom::bindings::utils::jsstring_to_str;
use dom::bindings::utils::unwrap_jsmanaged; use dom::bindings::utils::unwrap_jsmanaged;
use servo_util::str::DOMString; use servo_util::str::DOMString;
@ -293,9 +293,9 @@ impl FromJSValConvertible<()> for ByteString {
} }
} }
impl<T: Reflectable> ToJSValConvertible for JS<T> { impl ToJSValConvertible for Reflector {
fn to_jsval(&self, cx: *JSContext) -> JSVal { fn to_jsval(&self, cx: *JSContext) -> JSVal {
let obj = self.reflector().get_jsobject(); let obj = self.get_jsobject();
assert!(obj.is_not_null()); assert!(obj.is_not_null());
let mut value = ObjectValue(unsafe { &*obj }); let mut value = ObjectValue(unsafe { &*obj });
if unsafe { JS_WrapValue(cx, &mut value as *mut JSVal as *JSVal) } == 0 { if unsafe { JS_WrapValue(cx, &mut value as *mut JSVal as *JSVal) } == 0 {
@ -316,6 +316,18 @@ impl<T: Reflectable+IDLInterface> FromJSValConvertible<()> for JS<T> {
} }
} }
impl<T: Reflectable> ToJSValConvertible for JS<T> {
fn to_jsval(&self, cx: *JSContext) -> JSVal {
self.reflector().to_jsval(cx)
}
}
impl<'a, T: Reflectable> ToJSValConvertible for JSRef<'a, T> {
fn to_jsval(&self, cx: *JSContext) -> JSVal {
self.reflector().to_jsval(cx)
}
}
impl<T: ToJSValConvertible> ToJSValConvertible for Option<T> { impl<T: ToJSValConvertible> ToJSValConvertible for Option<T> {
fn to_jsval(&self, cx: *JSContext) -> JSVal { fn to_jsval(&self, cx: *JSContext) -> JSVal {
match self { match self {

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

@ -4,11 +4,13 @@
use dom::bindings::utils::{Reflector, Reflectable}; use dom::bindings::utils::{Reflector, Reflectable};
use dom::window::Window; use dom::window::Window;
use js::jsapi::JSContext; use js::jsapi::{JSObject, JSContext};
use layout_interface::TrustedNodeAddress; use layout_interface::TrustedNodeAddress;
use std::cast; use std::cast;
use std::cell::RefCell; use std::cell::{Cell, RefCell};
use std::ptr;
//use std::ops::{Deref, DerefMut};
pub struct JS<T> { pub struct JS<T> {
ptr: RefCell<*mut T> ptr: RefCell<*mut T>
@ -31,8 +33,8 @@ impl <T> Clone for JS<T> {
impl<T: Reflectable> JS<T> { impl<T: Reflectable> JS<T> {
pub fn new(obj: ~T, pub fn new(obj: ~T,
window: &JS<Window>, window: &JSRef<Window>,
wrap_fn: extern "Rust" fn(*JSContext, &JS<Window>, ~T) -> JS<T>) -> JS<T> { wrap_fn: extern "Rust" fn(*JSContext, &JSRef<Window>, ~T) -> JS<T>) -> JS<T> {
wrap_fn(window.get().get_cx(), window, obj) wrap_fn(window.get().get_cx(), window, obj)
} }
@ -49,6 +51,10 @@ impl<T: Reflectable> JS<T> {
ptr: RefCell::new(addr as *mut T) ptr: RefCell::new(addr as *mut T)
} }
} }
pub fn root<'a>(&self, collection: &'a RootCollection) -> Root<'a, T> {
collection.new_root(self)
}
} }
impl<T: Reflectable> Reflectable for JS<T> { impl<T: Reflectable> Reflectable for JS<T> {
@ -94,3 +100,213 @@ impl<From, To> JS<From> {
cast::transmute_copy(self) cast::transmute_copy(self)
} }
} }
pub trait RootedReference<T> {
fn root_ref<'a>(&'a self) -> Option<JSRef<'a, T>>;
}
impl<'a, T: Reflectable> RootedReference<T> for Option<Root<'a, T>> {
fn root_ref<'a>(&'a self) -> Option<JSRef<'a, T>> {
self.as_ref().map(|root| root.root_ref())
}
}
#[deriving(Eq, Clone)]
struct RootReference(*JSObject);
impl RootReference {
fn new<'a, T: Reflectable>(unrooted: &Root<'a, T>) -> RootReference {
RootReference(unrooted.rooted())
}
fn null() -> RootReference {
RootReference(ptr::null())
}
}
static MAX_STACK_ROOTS: uint = 10;
pub struct RootCollection {
roots: [Cell<RootReference>, ..MAX_STACK_ROOTS],
current: Cell<uint>,
}
impl RootCollection {
pub fn new() -> RootCollection {
RootCollection {
roots: [Cell::new(RootReference::null()), ..MAX_STACK_ROOTS],
current: Cell::new(0),
}
}
fn new_root<'a, T: Reflectable>(&'a self, unrooted: &JS<T>) -> Root<'a, T> {
Root::new(self, unrooted)
}
fn root_impl(&self, unrooted: RootReference) {
let current = self.current.get();
assert!(current < MAX_STACK_ROOTS);
self.roots[current].set(unrooted);
self.current.set(current + 1);
}
fn root<'a, T: Reflectable>(&self, unrooted: &Root<'a, T>) {
self.root_impl(RootReference::new(unrooted));
}
pub fn root_raw(&self, unrooted: *JSObject) {
self.root_impl(RootReference(unrooted));
}
fn unroot_impl(&self, rooted: RootReference) {
let mut current = self.current.get();
assert!(current != 0);
current -= 1;
assert!(self.roots[current].get() == rooted);
self.roots[current].set(RootReference::null());
self.current.set(current);
}
fn unroot<'a, T: Reflectable>(&self, rooted: &Root<'a, T>) {
self.unroot_impl(RootReference::new(rooted));
}
pub fn unroot_raw(&self, rooted: *JSObject) {
self.unroot_impl(RootReference(rooted));
}
}
pub struct Root<'a, T> {
root_list: &'a RootCollection,
ptr: RefCell<*mut T>,
}
impl<'a, T: Reflectable> Root<'a, T> {
fn new(roots: &'a RootCollection, unrooted: &JS<T>) -> Root<'a, T> {
let root = Root {
root_list: roots,
ptr: unrooted.ptr.clone()
};
roots.root(&root);
root
}
pub fn get<'a>(&'a self) -> &'a T {
unsafe {
let borrow = self.ptr.borrow();
&**borrow
}
}
pub fn get_mut<'a>(&'a mut self) -> &'a mut T {
unsafe {
let mut borrow = self.ptr.borrow_mut();
&mut **borrow
}
}
fn rooted(&self) -> *JSObject {
self.reflector().get_jsobject()
}
pub fn root_ref<'b>(&'b self) -> JSRef<'b,T> {
unsafe {
JSRef {
ptr: self.ptr.clone(),
chain: ::std::cast::transmute_region(&()),
}
}
}
}
#[unsafe_destructor]
impl<'a, T: Reflectable> Drop for Root<'a, T> {
fn drop(&mut self) {
self.root_list.unroot(self);
}
}
impl<'a, T: Reflectable> Reflectable for Root<'a, T> {
fn reflector<'a>(&'a self) -> &'a Reflector {
self.get().reflector()
}
fn mut_reflector<'a>(&'a mut self) -> &'a mut Reflector {
self.get_mut().mut_reflector()
}
}
/*impl<'a, T> Deref for Root<'a, T> {
fn deref<'a>(&'a self) -> &'a T {
self.get()
}
}
impl<'a, T> DerefMut for Root<'a, T> {
fn deref_mut<'a>(&'a mut self) -> &'a mut T {
self.get_mut()
}
}*/
/// Encapsulates a reference to something that is guaranteed to be alive. This is freely copyable.
pub struct JSRef<'a, T> {
ptr: RefCell<*mut T>,
chain: &'a (),
}
impl<'a, T> Clone for JSRef<'a, T> {
fn clone(&self) -> JSRef<'a, T> {
JSRef {
ptr: self.ptr.clone(),
chain: self.chain
}
}
}
impl<'a, T> Eq for JSRef<'a, T> {
fn eq(&self, other: &JSRef<T>) -> bool {
self.ptr == other.ptr
}
}
impl<'a,T> JSRef<'a,T> {
pub fn get<'a>(&'a self) -> &'a T {
unsafe {
let borrow = self.ptr.borrow();
&**borrow
}
}
pub fn get_mut<'a>(&'a mut self) -> &'a mut T {
let mut borrowed = self.ptr.borrow_mut();
unsafe {
&mut **borrowed
}
}
//XXXjdm It would be lovely if this could be private.
pub unsafe fn transmute<'b, To>(&'b self) -> &'b JSRef<'a, To> {
cast::transmute(self)
}
//XXXjdm It would be lovely if this could be private.
pub unsafe fn transmute_mut<'b, To>(&'b mut self) -> &'b mut JSRef<'a, To> {
cast::transmute(self)
}
pub fn unrooted(&self) -> JS<T> {
JS {
ptr: self.ptr.clone()
}
}
}
impl<'a, T: Reflectable> Reflectable for JSRef<'a, T> {
fn reflector<'a>(&'a self) -> &'a Reflector {
self.get().reflector()
}
fn mut_reflector<'a>(&'a mut self) -> &'a mut Reflector {
self.get_mut().mut_reflector()
}
}

24
src/components/script/dom/bindings/trace.rs
View file

@ -6,6 +6,7 @@ use dom::bindings::js::JS;
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use js::jsapi::{JSObject, JSTracer, JS_CallTracer, JSTRACE_OBJECT}; use js::jsapi::{JSObject, JSTracer, JS_CallTracer, JSTRACE_OBJECT};
use js::jsval::JSVal;
use libc; use libc;
use std::cast; use std::cast;
@ -42,6 +43,22 @@ pub trait JSTraceable {
fn trace(&self, trc: *mut JSTracer); fn trace(&self, trc: *mut JSTracer);
} }
pub fn trace_jsval(tracer: *mut JSTracer, description: &str, val: JSVal) {
if !val.is_gcthing() {
return;
}
unsafe {
description.to_c_str().with_ref(|name| {
(*tracer).debugPrinter = ptr::null();
(*tracer).debugPrintIndex = -1;
(*tracer).debugPrintArg = name as *libc::c_void;
debug!("tracing value {:s}", description);
JS_CallTracer(tracer as *JSTracer, val.to_gcthing(), val.trace_kind());
});
}
}
pub fn trace_reflector(tracer: *mut JSTracer, description: &str, reflector: &Reflector) { pub fn trace_reflector(tracer: *mut JSTracer, description: &str, reflector: &Reflector) {
trace_object(tracer, description, reflector.get_jsobject()) trace_object(tracer, description, reflector.get_jsobject())
} }
@ -132,3 +149,10 @@ impl<S: Encoder<E>, E> Encodable<S, E> for Traceable<*JSObject> {
Ok(()) Ok(())
} }
} }
impl<S: Encoder<E>, E> Encodable<S, E> for Traceable<JSVal> {
fn encode(&self, s: &mut S) -> Result<(), E> {
trace_jsval(get_jstracer(s), "val", **self);
Ok(())
}
}

27
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; use dom::bindings::js::{JS, JSRef};
use dom::bindings::trace::Untraceable; use dom::bindings::trace::Untraceable;
use dom::browsercontext; use dom::browsercontext;
use dom::window; use dom::window;
@ -37,7 +37,6 @@ use js::jsapi::{JSContext, JSObject, JSBool, jsid, JSClass, JSNative};
use js::jsapi::{JSFunctionSpec, JSPropertySpec}; use js::jsapi::{JSFunctionSpec, JSPropertySpec};
use js::jsapi::{JS_NewGlobalObject, JS_InitStandardClasses}; use js::jsapi::{JS_NewGlobalObject, JS_InitStandardClasses};
use js::jsapi::{JSString}; use js::jsapi::{JSString};
use js::jsapi::{JS_AllowGC, JS_InhibitGC};
use js::jsfriendapi::bindgen::JS_NewObjectWithUniqueType; use js::jsfriendapi::bindgen::JS_NewObjectWithUniqueType;
use js::jsval::JSVal; use js::jsval::JSVal;
use js::jsval::{PrivateValue, ObjectValue, NullValue, ObjectOrNullValue}; use js::jsval::{PrivateValue, ObjectValue, NullValue, ObjectOrNullValue};
@ -390,8 +389,8 @@ pub trait Reflectable {
pub fn reflect_dom_object<T: Reflectable> pub fn reflect_dom_object<T: Reflectable>
(obj: ~T, (obj: ~T,
window: &JS<window::Window>, window: &JSRef<window::Window>,
wrap_fn: extern "Rust" fn(*JSContext, &JS<window::Window>, ~T) -> JS<T>) wrap_fn: extern "Rust" fn(*JSContext, &JSRef<window::Window>, ~T) -> JS<T>)
-> JS<T> { -> JS<T> {
JS::new(obj, window, wrap_fn) JS::new(obj, window, wrap_fn)
} }
@ -637,26 +636,6 @@ pub fn cx_for_dom_object<T: Reflectable>(obj: &T) -> *JSContext {
cx_for_dom_reflector(obj.reflector().get_jsobject()) cx_for_dom_reflector(obj.reflector().get_jsobject())
} }
/// Execute arbitrary code with the JS GC enabled, then disable it afterwards.
pub fn with_gc_enabled<R>(cx: *JSContext, f: || -> R) -> R {
unsafe {
JS_AllowGC(cx);
let rv = f();
JS_InhibitGC(cx);
rv
}
}
/// Execute arbitrary code with the JS GC disabled, then enable it afterwards.
pub fn with_gc_disabled<R>(cx: *JSContext, f: || -> R) -> R {
unsafe {
JS_InhibitGC(cx);
let rv = f();
JS_AllowGC(cx);
rv
}
}
/// Check if an element name is valid. See http://www.w3.org/TR/xml/#NT-Name /// Check if an element name is valid. See http://www.w3.org/TR/xml/#NT-Name
/// for details. /// for details.
#[deriving(Eq)] #[deriving(Eq)]

12
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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;
@ -23,15 +23,15 @@ impl Blob {
} }
} }
pub fn new(window: &JS<Window>) -> JS<Blob> { pub fn new(window: &JSRef<Window>) -> JS<Blob> {
reflect_dom_object(~Blob::new_inherited(window.clone()), reflect_dom_object(~Blob::new_inherited(window.unrooted()),
window, window,
BlobBinding::Wrap) BlobBinding::Wrap)
} }
} }
impl Blob { impl Blob {
pub fn Constructor(window: &JS<Window>) -> Fallible<JS<Blob>> { pub fn Constructor(window: &JSRef<Window>) -> Fallible<JS<Blob>> {
Ok(Blob::new(window)) Ok(Blob::new(window))
} }
@ -44,7 +44,9 @@ impl Blob {
} }
pub fn Slice(&self, _start: Option<i64>, _end: Option<i64>, _contentType: Option<DOMString>) -> JS<Blob> { pub fn Slice(&self, _start: Option<i64>, _end: Option<i64>, _contentType: Option<DOMString>) -> JS<Blob> {
Blob::new(&self.window) let roots = RootCollection::new();
let window = self.window.root(&roots);
Blob::new(&window.root_ref())
} }
pub fn Close(&self) {} pub fn Close(&self) {}

6
src/components/script/dom/clientrect.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::ClientRectBinding; use dom::bindings::codegen::BindingDeclarations::ClientRectBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window; use dom::window::Window;
use servo_util::geometry::Au; use servo_util::geometry::Au;
@ -32,10 +32,10 @@ impl ClientRect {
} }
} }
pub fn new(window: &JS<Window>, pub fn new(window: &JSRef<Window>,
top: Au, bottom: Au, top: Au, bottom: Au,
left: Au, right: Au) -> JS<ClientRect> { left: Au, right: Au) -> JS<ClientRect> {
let rect = ClientRect::new_inherited(window.clone(), top, bottom, left, right); let rect = ClientRect::new_inherited(window.unrooted(), top, bottom, left, right);
reflect_dom_object(~rect, window, ClientRectBinding::Wrap) reflect_dom_object(~rect, window, ClientRectBinding::Wrap)
} }

6
src/components/script/dom/clientrectlist.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::ClientRectListBinding; use dom::bindings::codegen::BindingDeclarations::ClientRectListBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::clientrect::ClientRect; use dom::clientrect::ClientRect;
use dom::window::Window; use dom::window::Window;
@ -25,9 +25,9 @@ impl ClientRectList {
} }
} }
pub fn new(window: &JS<Window>, pub fn new(window: &JSRef<Window>,
rects: Vec<JS<ClientRect>>) -> JS<ClientRectList> { rects: Vec<JS<ClientRect>>) -> JS<ClientRectList> {
reflect_dom_object(~ClientRectList::new_inherited(window.clone(), rects), reflect_dom_object(~ClientRectList::new_inherited(window.unrooted(), rects),
window, ClientRectListBinding::Wrap) window, ClientRectListBinding::Wrap)
} }

14
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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;
@ -35,12 +35,16 @@ impl Comment {
} }
} }
pub fn new(text: DOMString, document: &JS<Document>) -> JS<Comment> { pub fn new(text: DOMString, document: &JSRef<Document>) -> JS<Comment> {
let node = Comment::new_inherited(text, document.clone()); let node = Comment::new_inherited(text, document.unrooted());
Node::reflect_node(~node, document, CommentBinding::Wrap) Node::reflect_node(~node, document, CommentBinding::Wrap)
} }
pub fn Constructor(owner: &JS<Window>, data: DOMString) -> Fallible<JS<Comment>> { pub fn Constructor(owner: &JSRef<Window>, data: DOMString) -> Fallible<JS<Comment>> {
Ok(Comment::new(data, &owner.get().Document())) let roots = RootCollection::new();
let document = owner.get().Document();
let document = document.root(&roots);
Ok(Comment::new(data, &document.root_ref()))
} }
} }

4
src/components/script/dom/console.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::ConsoleBinding; use dom::bindings::codegen::BindingDeclarations::ConsoleBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window; use dom::window::Window;
use servo_util::str::DOMString; use servo_util::str::DOMString;
@ -20,7 +20,7 @@ impl Console {
} }
} }
pub fn new(window: &JS<Window>) -> JS<Console> { pub fn new(window: &JSRef<Window>) -> JS<Console> {
reflect_dom_object(~Console::new_inherited(), window, ConsoleBinding::Wrap) reflect_dom_object(~Console::new_inherited(), window, ConsoleBinding::Wrap)
} }

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

@ -7,7 +7,7 @@ use dom::bindings::codegen::InheritTypes::{DocumentBase, NodeCast, DocumentCast}
use dom::bindings::codegen::InheritTypes::{HTMLHeadElementCast, TextCast, ElementCast}; use dom::bindings::codegen::InheritTypes::{HTMLHeadElementCast, TextCast, ElementCast};
use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, HTMLHtmlElementCast}; use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, HTMLHtmlElementCast};
use dom::bindings::codegen::BindingDeclarations::DocumentBinding; use dom::bindings::codegen::BindingDeclarations::DocumentBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
use dom::bindings::error::{ErrorResult, Fallible, NotSupported, InvalidCharacter, HierarchyRequest, NamespaceError}; use dom::bindings::error::{ErrorResult, Fallible, NotSupported, InvalidCharacter, HierarchyRequest, NamespaceError};
@ -79,16 +79,18 @@ impl DocumentDerived for EventTarget {
impl Document { impl Document {
pub fn reflect_document<D: Reflectable+DocumentBase> pub fn reflect_document<D: Reflectable+DocumentBase>
(document: ~D, (document: ~D,
window: &JS<Window>, window: &JSRef<Window>,
wrap_fn: extern "Rust" fn(*JSContext, &JS<Window>, ~D) -> JS<D>) wrap_fn: extern "Rust" fn(*JSContext, &JSRef<Window>, ~D) -> JS<D>)
-> JS<D> { -> JS<D> {
let roots = RootCollection::new();
assert!(document.reflector().get_jsobject().is_null()); assert!(document.reflector().get_jsobject().is_null());
let raw_doc = reflect_dom_object(document, window, wrap_fn); let raw_doc = reflect_dom_object(document, window, wrap_fn);
assert!(raw_doc.reflector().get_jsobject().is_not_null()); assert!(raw_doc.reflector().get_jsobject().is_not_null());
let document = DocumentCast::from(&raw_doc); let document = DocumentCast::from(&raw_doc);
let document_root = document.root(&roots);
let mut node: JS<Node> = NodeCast::from(&document); let mut node: JS<Node> = NodeCast::from(&document);
node.get_mut().set_owner_doc(&document); node.get_mut().set_owner_doc(&document_root.root_ref());
raw_doc raw_doc
} }
@ -122,8 +124,8 @@ impl Document {
} }
} }
pub fn new(window: &JS<Window>, url: Option<Url>, doctype: IsHTMLDocument, content_type: Option<DOMString>) -> JS<Document> { pub fn new(window: &JSRef<Window>, url: Option<Url>, doctype: IsHTMLDocument, content_type: Option<DOMString>) -> JS<Document> {
let document = Document::new_inherited(window.clone(), url, doctype, content_type); let document = Document::new_inherited(window.unrooted(), url, doctype, content_type);
Document::reflect_document(~document, window, DocumentBinding::Wrap) Document::reflect_document(~document, window, DocumentBinding::Wrap)
} }
} }
@ -136,7 +138,7 @@ impl Document {
impl Document { impl Document {
// http://dom.spec.whatwg.org/#dom-document // http://dom.spec.whatwg.org/#dom-document
pub fn Constructor(owner: &JS<Window>) -> Fallible<JS<Document>> { pub fn Constructor(owner: &JSRef<Window>) -> Fallible<JS<Document>> {
Ok(Document::new(owner, None, NonHTMLDocument, None)) Ok(Document::new(owner, None, NonHTMLDocument, None))
} }
} }
@ -155,7 +157,9 @@ impl Document {
// http://dom.spec.whatwg.org/#dom-document-implementation // http://dom.spec.whatwg.org/#dom-document-implementation
pub fn Implementation(&mut self) -> JS<DOMImplementation> { pub fn Implementation(&mut self) -> JS<DOMImplementation> {
if self.implementation.is_none() { if self.implementation.is_none() {
self.implementation = Some(DOMImplementation::new(&self.window)); let roots = RootCollection::new();
let window = self.window.root(&roots);
self.implementation = Some(DOMImplementation::new(&window.root_ref()));
} }
self.implementation.get_ref().clone() self.implementation.get_ref().clone()
} }
@ -212,22 +216,30 @@ impl Document {
} }
// http://dom.spec.whatwg.org/#dom-document-getelementsbytagname // http://dom.spec.whatwg.org/#dom-document-getelementsbytagname
pub fn GetElementsByTagName(&self, abstract_self: &JS<Document>, tag_name: DOMString) -> JS<HTMLCollection> { pub fn GetElementsByTagName(&self, abstract_self: &JSRef<Document>, tag_name: DOMString) -> JS<HTMLCollection> {
HTMLCollection::by_tag_name(&self.window, &NodeCast::from(abstract_self), tag_name) let roots = RootCollection::new();
let window = self.window.root(&roots);
HTMLCollection::by_tag_name(&window.root_ref(), NodeCast::from_ref(abstract_self), tag_name)
} }
// http://dom.spec.whatwg.org/#dom-document-getelementsbytagnamens // http://dom.spec.whatwg.org/#dom-document-getelementsbytagnamens
pub fn GetElementsByTagNameNS(&self, abstract_self: &JS<Document>, maybe_ns: Option<DOMString>, tag_name: DOMString) -> JS<HTMLCollection> { pub fn GetElementsByTagNameNS(&self, abstract_self: &JSRef<Document>, maybe_ns: Option<DOMString>, tag_name: DOMString) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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),
None => Null None => Null
}; };
HTMLCollection::by_tag_name_ns(&self.window, &NodeCast::from(abstract_self), tag_name, namespace) HTMLCollection::by_tag_name_ns(&window.root_ref(), NodeCast::from_ref(abstract_self), tag_name, namespace)
} }
// http://dom.spec.whatwg.org/#dom-document-getelementsbyclassname // http://dom.spec.whatwg.org/#dom-document-getelementsbyclassname
pub fn GetElementsByClassName(&self, abstract_self: &JS<Document>, classes: DOMString) -> JS<HTMLCollection> { pub fn GetElementsByClassName(&self, abstract_self: &JSRef<Document>, classes: DOMString) -> JS<HTMLCollection> {
HTMLCollection::by_class_name(&self.window, &NodeCast::from(abstract_self), classes) let roots = RootCollection::new();
let window = self.window.root(&roots);
HTMLCollection::by_class_name(&window.root_ref(), NodeCast::from_ref(abstract_self), classes)
} }
// http://dom.spec.whatwg.org/#dom-nonelementparentnode-getelementbyid // http://dom.spec.whatwg.org/#dom-nonelementparentnode-getelementbyid
@ -239,7 +251,7 @@ impl Document {
} }
// http://dom.spec.whatwg.org/#dom-document-createelement // http://dom.spec.whatwg.org/#dom-document-createelement
pub fn CreateElement(&self, abstract_self: &JS<Document>, local_name: DOMString) pub fn CreateElement(&self, abstract_self: &JSRef<Document>, local_name: DOMString)
-> Fallible<JS<Element>> { -> Fallible<JS<Element>> {
if xml_name_type(local_name) == InvalidXMLName { if xml_name_type(local_name) == InvalidXMLName {
debug!("Not a valid element name"); debug!("Not a valid element name");
@ -250,7 +262,7 @@ impl Document {
} }
// http://dom.spec.whatwg.org/#dom-document-createelementns // http://dom.spec.whatwg.org/#dom-document-createelementns
pub fn CreateElementNS(&self, abstract_self: &JS<Document>, pub fn CreateElementNS(&self, abstract_self: &JSRef<Document>,
namespace: Option<DOMString>, namespace: Option<DOMString>,
qualified_name: DOMString) -> Fallible<JS<Element>> { qualified_name: DOMString) -> Fallible<JS<Element>> {
let ns = Namespace::from_str(null_str_as_empty_ref(&namespace)); let ns = Namespace::from_str(null_str_as_empty_ref(&namespace));
@ -296,23 +308,23 @@ impl Document {
} }
// http://dom.spec.whatwg.org/#dom-document-createdocumentfragment // http://dom.spec.whatwg.org/#dom-document-createdocumentfragment
pub fn CreateDocumentFragment(&self, abstract_self: &JS<Document>) -> JS<DocumentFragment> { pub fn CreateDocumentFragment(&self, abstract_self: &JSRef<Document>) -> JS<DocumentFragment> {
DocumentFragment::new(abstract_self) DocumentFragment::new(abstract_self)
} }
// http://dom.spec.whatwg.org/#dom-document-createtextnode // http://dom.spec.whatwg.org/#dom-document-createtextnode
pub fn CreateTextNode(&self, abstract_self: &JS<Document>, data: DOMString) pub fn CreateTextNode(&self, abstract_self: &JSRef<Document>, data: DOMString)
-> JS<Text> { -> JS<Text> {
Text::new(data, abstract_self) Text::new(data, abstract_self)
} }
// http://dom.spec.whatwg.org/#dom-document-createcomment // http://dom.spec.whatwg.org/#dom-document-createcomment
pub fn CreateComment(&self, abstract_self: &JS<Document>, data: DOMString) -> JS<Comment> { pub fn CreateComment(&self, abstract_self: &JSRef<Document>, data: DOMString) -> JS<Comment> {
Comment::new(data, abstract_self) Comment::new(data, abstract_self)
} }
// http://dom.spec.whatwg.org/#dom-document-createprocessinginstruction // http://dom.spec.whatwg.org/#dom-document-createprocessinginstruction
pub fn CreateProcessingInstruction(&self, abstract_self: &JS<Document>, target: DOMString, pub fn CreateProcessingInstruction(&self, abstract_self: &JSRef<Document>, target: DOMString,
data: DOMString) -> Fallible<JS<ProcessingInstruction>> { data: DOMString) -> Fallible<JS<ProcessingInstruction>> {
// Step 1. // Step 1.
if xml_name_type(target) == InvalidXMLName { if xml_name_type(target) == InvalidXMLName {
@ -329,9 +341,9 @@ impl Document {
} }
// http://dom.spec.whatwg.org/#dom-document-importnode // http://dom.spec.whatwg.org/#dom-document-importnode
pub fn ImportNode(&self, abstract_self: &JS<Document>, node: &JS<Node>, deep: bool) -> Fallible<JS<Node>> { pub fn ImportNode(&self, abstract_self: &JSRef<Document>, node: &JSRef<Node>, deep: bool) -> Fallible<JS<Node>> {
// Step 1. // Step 1.
if node.is_document() { if node.unrooted().is_document() {
return Err(NotSupported); return Err(NotSupported);
} }
@ -345,9 +357,9 @@ impl Document {
} }
// http://dom.spec.whatwg.org/#dom-document-adoptnode // http://dom.spec.whatwg.org/#dom-document-adoptnode
pub fn AdoptNode(&self, abstract_self: &JS<Document>, node: &JS<Node>) -> Fallible<JS<Node>> { pub fn AdoptNode(&self, abstract_self: &JSRef<Document>, node: &JSRef<Node>) -> Fallible<JS<Node>> {
// Step 1. // Step 1.
if node.is_document() { if node.unrooted().is_document() {
return Err(NotSupported); return Err(NotSupported);
} }
@ -356,22 +368,25 @@ impl Document {
Node::adopt(&mut adoptee, abstract_self); Node::adopt(&mut adoptee, abstract_self);
// Step 3. // Step 3.
Ok(adoptee) Ok(adoptee.unrooted())
} }
// http://dom.spec.whatwg.org/#dom-document-createevent // http://dom.spec.whatwg.org/#dom-document-createevent
pub fn CreateEvent(&self, interface: DOMString) -> Fallible<JS<Event>> { pub fn CreateEvent(&self, interface: DOMString) -> Fallible<JS<Event>> {
let roots = RootCollection::new();
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)
"uievents" | "uievent" => Ok(EventCast::from(&UIEvent::new(&self.window))), "uievents" | "uievent" => Ok(EventCast::from(&UIEvent::new(&window.root_ref()))),
"mouseevents" | "mouseevent" => Ok(EventCast::from(&MouseEvent::new(&self.window))), "mouseevents" | "mouseevent" => Ok(EventCast::from(&MouseEvent::new(&window.root_ref()))),
"htmlevents" | "events" | "event" => Ok(Event::new(&self.window)), "htmlevents" | "events" | "event" => Ok(Event::new(&window.root_ref())),
_ => Err(NotSupported) _ => Err(NotSupported)
} }
} }
// http://www.whatwg.org/specs/web-apps/current-work/#document.title // http://www.whatwg.org/specs/web-apps/current-work/#document.title
pub fn Title(&self, _: &JS<Document>) -> DOMString { pub fn Title(&self, _: &JSRef<Document>) -> DOMString {
let mut title = ~""; let mut title = ~"";
self.GetDocumentElement().map(|root| { self.GetDocumentElement().map(|root| {
let root: JS<Node> = NodeCast::from(&root); let root: JS<Node> = NodeCast::from(&root);
@ -392,7 +407,9 @@ impl Document {
} }
// http://www.whatwg.org/specs/web-apps/current-work/#document.title // http://www.whatwg.org/specs/web-apps/current-work/#document.title
pub fn SetTitle(&self, abstract_self: &JS<Document>, title: DOMString) -> ErrorResult { pub fn SetTitle(&self, abstract_self: &JSRef<Document>, title: DOMString) -> ErrorResult {
let roots = RootCollection::new();
self.GetDocumentElement().map(|root| { self.GetDocumentElement().map(|root| {
let root: JS<Node> = NodeCast::from(&root); let root: JS<Node> = NodeCast::from(&root);
let mut head_node = root.traverse_preorder().find(|child| { let mut head_node = root.traverse_preorder().find(|child| {
@ -405,18 +422,25 @@ impl Document {
match title_node { match title_node {
Some(ref mut title_node) => { Some(ref mut title_node) => {
for mut title_child in title_node.children() { for title_child in title_node.children() {
assert!(title_node.RemoveChild(&mut title_child).is_ok()); let title_child = title_child.root(&roots);
assert!(title_node.RemoveChild(&mut title_child.root_ref()).is_ok());
} }
let new_text = self.CreateTextNode(abstract_self, title.clone()); let new_text = self.CreateTextNode(abstract_self, title.clone());
assert!(title_node.AppendChild(&mut NodeCast::from(&new_text)).is_ok()); let new_text = new_text.root(&roots);
assert!(title_node.AppendChild(NodeCast::from_mut_ref(&mut new_text.root_ref())).is_ok());
}, },
None => { None => {
let mut new_title: JS<Node> = let mut new_title: JS<Node> =
NodeCast::from(&HTMLTitleElement::new(~"title", abstract_self)); NodeCast::from(&HTMLTitleElement::new(~"title", abstract_self));
let new_title_root = new_title.root(&roots);
let new_text = self.CreateTextNode(abstract_self, title.clone()); let new_text = self.CreateTextNode(abstract_self, title.clone());
assert!(new_title.AppendChild(&mut NodeCast::from(&new_text)).is_ok()); let new_text = new_text.root(&roots);
assert!(head.AppendChild(&mut new_title).is_ok());
assert!(new_title.AppendChild(NodeCast::from_mut_ref(&mut new_text.root_ref())).is_ok());
assert!(head.AppendChild(&mut new_title_root.root_ref()).is_ok());
}, },
} }
}); });
@ -441,7 +465,7 @@ impl 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
pub fn GetBody(&self, _: &JS<Document>) -> Option<JS<HTMLElement>> { pub fn GetBody(&self, _: &JSRef<Document>) -> Option<JS<HTMLElement>> {
self.get_html_element().and_then(|root| { self.get_html_element().and_then(|root| {
let node: JS<Node> = NodeCast::from(&root); let node: JS<Node> = NodeCast::from(&root);
node.children().find(|child| { node.children().find(|child| {
@ -455,7 +479,9 @@ impl 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
pub fn SetBody(&self, abstract_self: &JS<Document>, new_body: Option<JS<HTMLElement>>) -> ErrorResult { pub fn SetBody(&self, abstract_self: &JSRef<Document>, new_body: Option<JSRef<HTMLElement>>) -> ErrorResult {
let roots = RootCollection::new();
// Step 1. // Step 1.
match new_body { match new_body {
Some(ref node) => { Some(ref node) => {
@ -469,7 +495,7 @@ impl Document {
// Step 2. // Step 2.
let old_body: Option<JS<HTMLElement>> = self.GetBody(abstract_self); let old_body: Option<JS<HTMLElement>> = self.GetBody(abstract_self);
if old_body == new_body { if old_body == new_body.as_ref().map(|new_body| new_body.unrooted()) {
return Ok(()); return Ok(());
} }
@ -478,14 +504,18 @@ impl Document {
// Step 4. // Step 4.
None => return Err(HierarchyRequest), None => return Err(HierarchyRequest),
Some(root) => { Some(root) => {
let mut new_body: JS<Node> = NodeCast::from(&new_body.unwrap()); let mut new_body_unwrapped = new_body.unwrap();
let new_body: &mut JSRef<Node> = NodeCast::from_mut_ref(&mut new_body_unwrapped);
let mut root: JS<Node> = NodeCast::from(&root); let mut root: JS<Node> = NodeCast::from(&root);
match old_body { match old_body {
Some(child) => { Some(child) => {
let mut child: JS<Node> = NodeCast::from(&child); let child: JS<Node> = NodeCast::from(&child);
assert!(root.ReplaceChild(&mut new_body, &mut child).is_ok()) let child = child.root(&roots);
assert!(root.ReplaceChild(new_body, &mut child.root_ref()).is_ok())
} }
None => assert!(root.AppendChild(&mut new_body).is_ok()) None => assert!(root.AppendChild(new_body).is_ok())
}; };
} }
} }
@ -495,132 +525,159 @@ impl 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
pub fn GetElementsByName(&self, name: DOMString) -> JS<NodeList> { pub fn GetElementsByName(&self, name: DOMString) -> JS<NodeList> {
self.createNodeList(|node| { self.createNodeList(|node| {
if !node.is_element() { if !node.get().is_element() {
return false; return false;
} }
let element: JS<Element> = ElementCast::to(node).unwrap(); let element: JS<Element> = ElementCast::to(&node.unrooted()).unwrap();
element.get_attribute(Null, "name").map_or(false, |attr| { element.get_attribute(Null, "name").map_or(false, |attr| {
attr.get().value_ref() == name attr.get().value_ref() == name
}) })
}) })
} }
pub fn Images(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Images(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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;
impl CollectionFilter for ImagesFilter { impl CollectionFilter for ImagesFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == ~"img" elem.get().local_name == ~"img"
} }
} }
let filter = ~ImagesFilter; let filter = ~ImagesFilter;
HTMLCollection::create(&self.window, &NodeCast::from(abstract_self), filter) HTMLCollection::create(&window.root_ref(), NodeCast::from_ref(abstract_self), filter)
} }
pub fn Embeds(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Embeds(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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;
impl CollectionFilter for EmbedsFilter { impl CollectionFilter for EmbedsFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == ~"embed" elem.get().local_name == ~"embed"
} }
} }
let filter = ~EmbedsFilter; let filter = ~EmbedsFilter;
HTMLCollection::create(&self.window, &NodeCast::from(abstract_self), filter) HTMLCollection::create(&window.root_ref(), NodeCast::from_ref(abstract_self), filter)
} }
pub fn Plugins(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Plugins(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
// FIXME: https://github.com/mozilla/servo/issues/1847 // FIXME: https://github.com/mozilla/servo/issues/1847
self.Embeds(abstract_self) self.Embeds(abstract_self)
} }
pub fn Links(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Links(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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;
impl CollectionFilter for LinksFilter { impl CollectionFilter for LinksFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
(elem.get().local_name == ~"a" || elem.get().local_name == ~"area") && (elem.get().local_name == ~"a" || elem.get().local_name == ~"area") &&
elem.get_attribute(Null, "href").is_some() elem.unrooted().get_attribute(Null, "href").is_some()
} }
} }
let filter = ~LinksFilter; let filter = ~LinksFilter;
HTMLCollection::create(&self.window, &NodeCast::from(abstract_self), filter) HTMLCollection::create(&window.root_ref(), NodeCast::from_ref(abstract_self), filter)
} }
pub fn Forms(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Forms(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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;
impl CollectionFilter for FormsFilter { impl CollectionFilter for FormsFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == ~"form" elem.get().local_name == ~"form"
} }
} }
let filter = ~FormsFilter; let filter = ~FormsFilter;
HTMLCollection::create(&self.window, &NodeCast::from(abstract_self), filter) HTMLCollection::create(&window.root_ref(), NodeCast::from_ref(abstract_self), filter)
} }
pub fn Scripts(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Scripts(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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;
impl CollectionFilter for ScriptsFilter { impl CollectionFilter for ScriptsFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == ~"script" elem.get().local_name == ~"script"
} }
} }
let filter = ~ScriptsFilter; let filter = ~ScriptsFilter;
HTMLCollection::create(&self.window, &NodeCast::from(abstract_self), filter) HTMLCollection::create(&window.root_ref(), NodeCast::from_ref(abstract_self), filter)
} }
pub fn Anchors(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Anchors(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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;
impl CollectionFilter for AnchorsFilter { impl CollectionFilter for AnchorsFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == ~"a" && elem.get_attribute(Null, "name").is_some() elem.get().local_name == ~"a" && elem.unrooted().get_attribute(Null, "name").is_some()
} }
} }
let filter = ~AnchorsFilter; let filter = ~AnchorsFilter;
HTMLCollection::create(&self.window, &NodeCast::from(abstract_self), filter) HTMLCollection::create(&window.root_ref(), NodeCast::from_ref(abstract_self), filter)
} }
pub fn Applets(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Applets(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let roots = RootCollection::new();
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;
impl CollectionFilter for AppletsFilter { impl CollectionFilter for AppletsFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == ~"applet" elem.get().local_name == ~"applet"
} }
} }
let filter = ~AppletsFilter; let filter = ~AppletsFilter;
HTMLCollection::create(&self.window, &NodeCast::from(abstract_self), filter) HTMLCollection::create(&window.root_ref(), NodeCast::from_ref(abstract_self), filter)
} }
pub fn Location(&mut self, abstract_self: &JS<Document>) -> JS<Location> { pub fn Location(&mut self, _abstract_self: &JSRef<Document>) -> JS<Location> {
self.window.get_mut().Location(&abstract_self.get().window) let roots = RootCollection::new();
let window = self.window.root(&roots);
self.window.get_mut().Location(&window.root_ref())
} }
pub fn Children(&self, abstract_self: &JS<Document>) -> JS<HTMLCollection> { pub fn Children(&self, abstract_self: &JSRef<Document>) -> JS<HTMLCollection> {
let doc = self.node.owner_doc(); let roots = RootCollection::new();
let doc = doc.get(); let window = self.window.root(&roots);
HTMLCollection::children(&doc.window, &NodeCast::from(abstract_self)) HTMLCollection::children(&window.root_ref(), NodeCast::from_ref(abstract_self))
} }
pub fn createNodeList(&self, callback: |node: &JS<Node>| -> bool) -> JS<NodeList> { pub fn createNodeList(&self, callback: |node: &JSRef<Node>| -> bool) -> JS<NodeList> {
let roots = RootCollection::new();
let window = self.window.root(&roots);
let mut nodes = vec!(); let mut nodes = vec!();
match self.GetDocumentElement() { match self.GetDocumentElement() {
None => {}, None => {},
Some(root) => { Some(root) => {
let root: JS<Node> = NodeCast::from(&root); let root: JS<Node> = NodeCast::from(&root);
for child in root.traverse_preorder() { for child in root.traverse_preorder() {
if callback(&child) { let child = child.root(&roots);
nodes.push(child.clone()); if callback(&child.root_ref()) {
nodes.push(child.root_ref().unrooted());
} }
} }
} }
} }
NodeList::new_simple_list(&self.window, nodes) NodeList::new_simple_list(&window.root_ref(), nodes)
} }
pub fn content_changed(&self) { pub fn content_changed(&self) {
@ -638,14 +695,14 @@ impl Document {
/// Remove any existing association between the provided id and any elements in this document. /// Remove any existing association between the provided id and any elements in this document.
pub fn unregister_named_element(&mut self, pub fn unregister_named_element(&mut self,
abstract_self: &JS<Element>, abstract_self: &JSRef<Element>,
id: DOMString) { id: DOMString) {
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()
.position(|element| element == abstract_self) .position(|element| element == &abstract_self.unrooted())
.expect("This element should be in registered."); .expect("This element should be in registered.");
elements.remove(position); elements.remove(position);
is_empty = elements.is_empty(); is_empty = elements.is_empty();
@ -658,10 +715,10 @@ impl Document {
/// Associate an element present in this document with the provided id. /// Associate an element present in this document with the provided id.
pub fn register_named_element(&mut self, pub fn register_named_element(&mut self,
element: &JS<Element>, element: &JSRef<Element>,
id: DOMString) { id: DOMString) {
assert!({ assert!({
let node: JS<Node> = NodeCast::from(element); let node: JS<Node> = NodeCast::from(&element.unrooted());
node.is_in_doc() node.is_in_doc()
}); });
@ -670,7 +727,7 @@ impl Document {
let root = self.GetDocumentElement().expect("The element is in the document, so there must be a document element."); let root = self.GetDocumentElement().expect("The element is in the document, so there must be a document element.");
match self.idmap.find_mut(&id) { match self.idmap.find_mut(&id) {
Some(elements) => { Some(elements) => {
let new_node = NodeCast::from(element); let new_node = NodeCast::from_ref(element);
let mut head : uint = 0u; let mut head : uint = 0u;
let root: JS<Node> = NodeCast::from(&root); let root: JS<Node> = NodeCast::from(&root);
for node in root.traverse_preorder() { for node in root.traverse_preorder() {
@ -679,18 +736,18 @@ impl Document {
if elements.get(head) == &elem { if elements.get(head) == &elem {
head = head + 1; head = head + 1;
} }
if new_node == node || head == elements.len() { if new_node.unrooted() == node || head == elements.len() {
break; break;
} }
} }
None => {} None => {}
} }
} }
elements.insert(head, element.clone()); elements.insert(head, element.unrooted());
return; return;
}, },
None => (), None => (),
} }
self.idmap.insert(id, vec!(element.clone())); self.idmap.insert(id, vec!(element.unrooted()));
} }
} }

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

@ -4,12 +4,12 @@
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
use dom::htmlcollection::HTMLCollection; use dom::htmlcollection::HTMLCollection;
use dom::node::{DocumentFragmentNodeTypeId, Node}; use dom::node::{DocumentFragmentNodeTypeId, Node, window_from_node};
use dom::window::Window; use dom::window::Window;
#[deriving(Encodable)] #[deriving(Encodable)]
@ -34,22 +34,26 @@ impl DocumentFragment {
} }
} }
pub fn new(document: &JS<Document>) -> JS<DocumentFragment> { pub fn new(document: &JSRef<Document>) -> JS<DocumentFragment> {
let node = DocumentFragment::new_inherited(document.clone()); let node = DocumentFragment::new_inherited(document.unrooted());
Node::reflect_node(~node, document, DocumentFragmentBinding::Wrap) Node::reflect_node(~node, document, DocumentFragmentBinding::Wrap)
} }
} }
impl DocumentFragment { impl DocumentFragment {
pub fn Constructor(owner: &JS<Window>) -> Fallible<JS<DocumentFragment>> { pub fn Constructor(owner: &JSRef<Window>) -> Fallible<JS<DocumentFragment>> {
Ok(DocumentFragment::new(&owner.get().Document())) let roots = RootCollection::new();
let document = owner.get().Document();
let document = document.root(&roots);
Ok(DocumentFragment::new(&document.root_ref()))
} }
} }
impl DocumentFragment { impl DocumentFragment {
pub fn Children(&self, abstract_self: &JS<DocumentFragment>) -> JS<HTMLCollection> { pub fn Children(&self, abstract_self: &JSRef<DocumentFragment>) -> JS<HTMLCollection> {
let doc = self.node.owner_doc(); let roots = RootCollection::new();
let doc = doc.get(); let window = window_from_node(&abstract_self.unrooted()).root(&roots);
HTMLCollection::children(&doc.window, &NodeCast::from(abstract_self)) HTMLCollection::children(&window.root_ref(), NodeCast::from_ref(abstract_self))
} }
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::InheritTypes::DocumentTypeDerived; use dom::bindings::codegen::InheritTypes::DocumentTypeDerived;
use dom::bindings::codegen::BindingDeclarations::DocumentTypeBinding; use dom::bindings::codegen::BindingDeclarations::DocumentTypeBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::node::{Node, DoctypeNodeTypeId}; use dom::node::{Node, DoctypeNodeTypeId};
@ -45,12 +45,12 @@ impl DocumentType {
pub fn new(name: DOMString, pub fn new(name: DOMString,
public_id: Option<DOMString>, public_id: Option<DOMString>,
system_id: Option<DOMString>, system_id: Option<DOMString>,
document: &JS<Document>) document: &JSRef<Document>)
-> JS<DocumentType> { -> JS<DocumentType> {
let documenttype = DocumentType::new_inherited(name, let documenttype = DocumentType::new_inherited(name,
public_id, public_id,
system_id, system_id,
document.clone()); document.unrooted());
Node::reflect_node(~documenttype, document, DocumentTypeBinding::Wrap) Node::reflect_node(~documenttype, document, DocumentTypeBinding::Wrap)
} }
} }

4
src/components/script/dom/domexception.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::DOMExceptionBinding; use dom::bindings::codegen::BindingDeclarations::DOMExceptionBinding;
use dom::bindings::codegen::BindingDeclarations::DOMExceptionBinding::DOMExceptionConstants; use dom::bindings::codegen::BindingDeclarations::DOMExceptionBinding::DOMExceptionConstants;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window; use dom::window::Window;
use servo_util::str::DOMString; use servo_util::str::DOMString;
@ -49,7 +49,7 @@ impl DOMException {
} }
} }
pub fn new(window: &JS<Window>, code: DOMErrorName) -> JS<DOMException> { pub fn new(window: &JSRef<Window>, code: DOMErrorName) -> JS<DOMException> {
reflect_dom_object(~DOMException::new_inherited(code), window, DOMExceptionBinding::Wrap) reflect_dom_object(~DOMException::new_inherited(code), window, DOMExceptionBinding::Wrap)
} }
} }

68
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -33,8 +33,8 @@ impl DOMImplementation {
} }
} }
pub fn new(owner: &JS<Window>) -> JS<DOMImplementation> { pub fn new(owner: &JSRef<Window>) -> JS<DOMImplementation> {
reflect_dom_object(~DOMImplementation::new_inherited(owner.clone()), owner, reflect_dom_object(~DOMImplementation::new_inherited(owner.unrooted()), owner,
DOMImplementationBinding::Wrap) DOMImplementationBinding::Wrap)
} }
} }
@ -53,28 +53,37 @@ impl Reflectable for DOMImplementation {
impl DOMImplementation { impl DOMImplementation {
// http://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype // http://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype
pub fn CreateDocumentType(&self, qname: DOMString, pubid: DOMString, sysid: DOMString) -> Fallible<JS<DocumentType>> { pub fn CreateDocumentType(&self, qname: DOMString, pubid: DOMString, sysid: DOMString) -> Fallible<JS<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),
// Step 2. // Step 2.
Name => Err(NamespaceError), Name => Err(NamespaceError),
// Step 3. // Step 3.
QName => Ok(DocumentType::new(qname, Some(pubid), Some(sysid), &self.owner.get().Document())) QName => {
let document = self.owner.get().Document();
let document = document.root(&roots);
Ok(DocumentType::new(qname, Some(pubid), Some(sysid), &document.root_ref()))
}
} }
} }
// http://dom.spec.whatwg.org/#dom-domimplementation-createdocument // http://dom.spec.whatwg.org/#dom-domimplementation-createdocument
pub fn CreateDocument(&self, namespace: Option<DOMString>, qname: DOMString, pub fn CreateDocument(&self, namespace: Option<DOMString>, qname: DOMString,
maybe_doctype: Option<JS<DocumentType>>) -> Fallible<JS<Document>> { mut maybe_doctype: Option<JSRef<DocumentType>>) -> Fallible<JS<Document>> {
let roots = RootCollection::new();
let win = self.owner.root(&roots);
// Step 1. // Step 1.
let doc = Document::new(&self.owner, None, NonHTMLDocument, None); let doc = Document::new(&win.root_ref(), None, NonHTMLDocument, None);
let doc_root = doc.root(&roots);
let mut doc_node: JS<Node> = NodeCast::from(&doc); let mut doc_node: JS<Node> = NodeCast::from(&doc);
// Step 2-3. // Step 2-3.
let maybe_elem = if qname.is_empty() { let mut maybe_elem = if qname.is_empty() {
None None
} else { } else {
match doc.get().CreateElementNS(&doc, namespace, qname) { match doc.get().CreateElementNS(&doc_root.root_ref(), namespace, qname) {
Err(error) => return Err(error), Err(error) => return Err(error),
Ok(elem) => Some(elem) Ok(elem) => Some(elem)
} }
@ -83,13 +92,16 @@ impl DOMImplementation {
// Step 4. // Step 4.
match maybe_doctype { match maybe_doctype {
None => (), None => (),
Some(ref doctype) => assert!(doc_node.AppendChild(&mut NodeCast::from(doctype)).is_ok()) Some(ref mut doctype) => assert!(doc_node.AppendChild(NodeCast::from_mut_ref(doctype)).is_ok())
} }
// Step 5. // Step 5.
match maybe_elem { match maybe_elem {
None => (), None => (),
Some(ref elem) => assert!(doc_node.AppendChild(&mut NodeCast::from(elem)).is_ok()) Some(ref elem) => {
let elem = elem.root(&roots);
assert!(doc_node.AppendChild(NodeCast::from_mut_ref(&mut elem.root_ref())).is_ok())
}
} }
// Step 6. // Step 6.
@ -101,44 +113,54 @@ impl DOMImplementation {
// http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument // http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
pub fn CreateHTMLDocument(&self, title: Option<DOMString>) -> JS<Document> { pub fn CreateHTMLDocument(&self, title: Option<DOMString>) -> JS<Document> {
let roots = RootCollection::new();
let owner = self.owner.root(&roots);
// Step 1-2. // Step 1-2.
let doc = Document::new(&self.owner, None, HTMLDocument, None); let doc = Document::new(&owner.root_ref(), None, HTMLDocument, None);
let doc_root = doc.root(&roots);
let mut doc_node: JS<Node> = NodeCast::from(&doc); let mut doc_node: JS<Node> = NodeCast::from(&doc);
{ {
// Step 3. // Step 3.
let doc_type = DocumentType::new(~"html", None, None, &doc); let doc_type = DocumentType::new(~"html", None, None, &doc_root.root_ref());
assert!(doc_node.AppendChild(&mut NodeCast::from(&doc_type)).is_ok()); let doc_type = doc_type.root(&roots);
assert!(doc_node.AppendChild(NodeCast::from_mut_ref(&mut doc_type.root_ref())).is_ok());
} }
{ {
// Step 4. // Step 4.
let mut doc_html = NodeCast::from(&HTMLHtmlElement::new(~"html", &doc)); let mut doc_html = NodeCast::from(&HTMLHtmlElement::new(~"html", &doc_root.root_ref()));
assert!(doc_node.AppendChild(&mut doc_html).is_ok()); let doc_html_root = {doc_html.root(&roots)};
assert!(doc_node.AppendChild(&mut doc_html_root.root_ref()).is_ok());
{ {
// Step 5. // Step 5.
let mut doc_head = NodeCast::from(&HTMLHeadElement::new(~"head", &doc)); let mut doc_head = NodeCast::from(&HTMLHeadElement::new(~"head", &doc_root.root_ref()));
assert!(doc_html.AppendChild(&mut doc_head).is_ok()); let doc_head_root = doc_head.root(&roots);
assert!(doc_html.AppendChild(&mut doc_head_root.root_ref()).is_ok());
// Step 6. // Step 6.
match title { match title {
None => (), None => (),
Some(title_str) => { Some(title_str) => {
// Step 6.1. // Step 6.1.
let mut doc_title = NodeCast::from(&HTMLTitleElement::new(~"title", &doc)); let mut doc_title = NodeCast::from(&HTMLTitleElement::new(~"title", &doc_root.root_ref()));
assert!(doc_head.AppendChild(&mut doc_title).is_ok()); let doc_title_root = doc_title.root(&roots);
assert!(doc_head.AppendChild(&mut doc_title_root.root_ref()).is_ok());
// Step 6.2. // Step 6.2.
let title_text = Text::new(title_str, &doc); let title_text = Text::new(title_str, &doc_root.root_ref());
assert!(doc_title.AppendChild(&mut NodeCast::from(&title_text)).is_ok()); let title_text = title_text.root(&roots);
assert!(doc_title.AppendChild(NodeCast::from_mut_ref(&mut title_text.root_ref())).is_ok());
} }
} }
} }
// Step 7. // Step 7.
let doc_body = HTMLBodyElement::new(~"body", &doc); let doc_body = HTMLBodyElement::new(~"body", &doc_root.root_ref());
assert!(doc_html.AppendChild(&mut NodeCast::from(&doc_body)).is_ok()); let doc_body = doc_body.root(&roots);
assert!(doc_html.AppendChild(NodeCast::from_mut_ref(&mut doc_body.root_ref())).is_ok());
} }
// Step 8. // Step 8.

14
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -25,12 +25,12 @@ impl DOMParser {
} }
} }
pub fn new(owner: &JS<Window>) -> JS<DOMParser> { pub fn new(owner: &JSRef<Window>) -> JS<DOMParser> {
reflect_dom_object(~DOMParser::new_inherited(owner.clone()), owner, reflect_dom_object(~DOMParser::new_inherited(owner.unrooted()), owner,
DOMParserBinding::Wrap) DOMParserBinding::Wrap)
} }
pub fn Constructor(owner: &JS<Window>) -> Fallible<JS<DOMParser>> { pub fn Constructor(owner: &JSRef<Window>) -> Fallible<JS<DOMParser>> {
Ok(DOMParser::new(owner)) Ok(DOMParser::new(owner))
} }
@ -38,12 +38,14 @@ impl DOMParser {
_s: DOMString, _s: DOMString,
ty: DOMParserBinding::SupportedType) ty: DOMParserBinding::SupportedType)
-> Fallible<JS<Document>> { -> Fallible<JS<Document>> {
let roots = RootCollection::new();
let owner = self.owner.root(&roots);
match ty { match ty {
Text_html => { Text_html => {
Ok(Document::new(&self.owner, None, HTMLDocument, Some(~"text/html"))) Ok(Document::new(&owner.root_ref(), None, HTMLDocument, Some(~"text/html")))
} }
Text_xml => { Text_xml => {
Ok(Document::new(&self.owner, None, NonHTMLDocument, Some(~"text/xml"))) Ok(Document::new(&owner.root_ref(), None, NonHTMLDocument, Some(~"text/xml")))
} }
_ => { _ => {
Err(FailureUnknown) Err(FailureUnknown)

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

@ -8,7 +8,7 @@ use dom::attr::{Attr, AttrSettingType, ReplacedAttr, FirstSetAttr};
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type}; use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type};
@ -19,6 +19,7 @@ use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::htmlcollection::HTMLCollection; use dom::htmlcollection::HTMLCollection;
use dom::htmlserializer::serialize; use dom::htmlserializer::serialize;
use dom::node::{ElementNodeTypeId, Node, NodeHelpers, NodeIterator, document_from_node}; use dom::node::{ElementNodeTypeId, Node, NodeHelpers, NodeIterator, document_from_node};
use dom::node::window_from_node;
use dom::virtualmethods::{VirtualMethods, vtable_for}; use dom::virtualmethods::{VirtualMethods, vtable_for};
use layout_interface::ContentChangedDocumentDamage; use layout_interface::ContentChangedDocumentDamage;
use layout_interface::MatchSelectorsDocumentDamage; use layout_interface::MatchSelectorsDocumentDamage;
@ -151,8 +152,8 @@ impl Element {
} }
} }
pub fn new(local_name: DOMString, namespace: Namespace, prefix: Option<DOMString>, document: &JS<Document>) -> JS<Element> { pub fn new(local_name: DOMString, namespace: Namespace, prefix: Option<DOMString>, document: &JSRef<Document>) -> JS<Element> {
let element = Element::new_inherited(ElementTypeId, local_name, namespace, prefix, document.clone()); let element = Element::new_inherited(ElementTypeId, local_name, namespace, prefix, document.unrooted());
Node::reflect_node(~element, document, ElementBinding::Wrap) Node::reflect_node(~element, document, ElementBinding::Wrap)
} }
@ -260,6 +261,7 @@ impl AttributeHandlers for JS<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: |&JS<Attr>| -> bool) { prefix: Option<DOMString>, cb: |&JS<Attr>| -> bool) {
let roots = RootCollection::new();
let node: JS<Node> = NodeCast::from(self); let node: JS<Node> = NodeCast::from(self);
let idx = self.get().attrs.iter().position(cb); let idx = self.get().attrs.iter().position(cb);
let (mut attr, set_type): (JS<Attr>, AttrSettingType) = match idx { let (mut attr, set_type): (JS<Attr>, AttrSettingType) = match idx {
@ -270,8 +272,9 @@ impl AttributeHandlers for JS<Element> {
None => { None => {
let doc = node.get().owner_doc().get(); let doc = node.get().owner_doc().get();
let attr = Attr::new(&doc.window, local_name.clone(), value.clone(), let window = doc.window.root(&roots);
name, namespace.clone(), prefix, self.clone()); let attr = Attr::new(&window.root_ref(), local_name.clone(), value.clone(),
name, namespace.clone(), prefix, self.clone());
self.get_mut().attrs.push(attr.clone()); self.get_mut().attrs.push(attr.clone());
(attr, FirstSetAttr) (attr, FirstSetAttr)
} }
@ -474,32 +477,34 @@ impl Element {
} }
// http://dom.spec.whatwg.org/#dom-element-id // http://dom.spec.whatwg.org/#dom-element-id
pub fn Id(&self, abstract_self: &JS<Element>) -> DOMString { pub fn Id(&self, abstract_self: &JSRef<Element>) -> DOMString {
abstract_self.get_string_attribute("id") abstract_self.unrooted().get_string_attribute("id")
} }
// http://dom.spec.whatwg.org/#dom-element-id // http://dom.spec.whatwg.org/#dom-element-id
pub fn SetId(&mut self, abstract_self: &mut JS<Element>, id: DOMString) { pub fn SetId(&mut self, abstract_self: &mut JSRef<Element>, id: DOMString) {
abstract_self.set_string_attribute("id", id); abstract_self.unrooted().set_string_attribute("id", id);
} }
// http://dom.spec.whatwg.org/#dom-element-classname // http://dom.spec.whatwg.org/#dom-element-classname
pub fn ClassName(&self, abstract_self: &JS<Element>) -> DOMString { pub fn ClassName(&self, abstract_self: &JSRef<Element>) -> DOMString {
abstract_self.get_string_attribute("class") abstract_self.unrooted().get_string_attribute("class")
} }
// http://dom.spec.whatwg.org/#dom-element-classname // http://dom.spec.whatwg.org/#dom-element-classname
pub fn SetClassName(&self, abstract_self: &mut JS<Element>, class: DOMString) { pub fn SetClassName(&self, abstract_self: &mut JSRef<Element>, class: DOMString) {
abstract_self.set_string_attribute("class", class); abstract_self.unrooted().set_string_attribute("class", class);
} }
// http://dom.spec.whatwg.org/#dom-element-attributes // http://dom.spec.whatwg.org/#dom-element-attributes
pub fn Attributes(&mut self, abstract_self: &JS<Element>) -> JS<AttrList> { pub fn Attributes(&mut self, abstract_self: &JSRef<Element>) -> JS<AttrList> {
let roots = RootCollection::new();
match self.attr_list { match self.attr_list {
None => { None => {
let doc = self.node.owner_doc(); let doc = self.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
let list = AttrList::new(&doc.window, abstract_self); let window = doc.window.root(&roots);
let list = AttrList::new(&window.root_ref(), abstract_self);
self.attr_list = Some(list.clone()); self.attr_list = Some(list.clone());
list list
} }
@ -508,142 +513,151 @@ impl Element {
} }
// http://dom.spec.whatwg.org/#dom-element-getattribute // http://dom.spec.whatwg.org/#dom-element-getattribute
pub fn GetAttribute(&self, abstract_self: &JS<Element>, name: DOMString) -> Option<DOMString> { pub fn GetAttribute(&self, abstract_self: &JSRef<Element>, name: DOMString) -> Option<DOMString> {
let name = if abstract_self.get().html_element_in_html_document() { let name = if abstract_self.get().html_element_in_html_document() {
name.to_ascii_lower() name.to_ascii_lower()
} else { } else {
name name
}; };
abstract_self.get_attribute(Null, name).map(|s| s.get().Value()) abstract_self.unrooted().get_attribute(Null, name).map(|s| s.get().Value())
} }
// http://dom.spec.whatwg.org/#dom-element-getattributens // http://dom.spec.whatwg.org/#dom-element-getattributens
pub fn GetAttributeNS(&self, abstract_self: &JS<Element>, pub fn GetAttributeNS(&self, abstract_self: &JSRef<Element>,
namespace: Option<DOMString>, namespace: Option<DOMString>,
local_name: DOMString) -> Option<DOMString> { local_name: DOMString) -> Option<DOMString> {
let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace)); let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace));
abstract_self.get_attribute(namespace, local_name) abstract_self.unrooted()
.get_attribute(namespace, local_name)
.map(|attr| attr.get().value.clone()) .map(|attr| attr.get().value.clone())
} }
// http://dom.spec.whatwg.org/#dom-element-setattribute // http://dom.spec.whatwg.org/#dom-element-setattribute
pub fn SetAttribute(&self, abstract_self: &mut JS<Element>, pub fn SetAttribute(&self, abstract_self: &mut JSRef<Element>,
name: DOMString, name: DOMString,
value: DOMString) -> ErrorResult { value: DOMString) -> ErrorResult {
abstract_self.SetAttribute(name, value) abstract_self.unrooted().SetAttribute(name, value)
} }
// http://dom.spec.whatwg.org/#dom-element-setattributens // http://dom.spec.whatwg.org/#dom-element-setattributens
pub fn SetAttributeNS(&self, pub fn SetAttributeNS(&self,
abstract_self: &mut JS<Element>, abstract_self: &mut JSRef<Element>,
namespace_url: Option<DOMString>, namespace_url: Option<DOMString>,
name: DOMString, name: DOMString,
value: DOMString) -> ErrorResult { value: DOMString) -> ErrorResult {
abstract_self.SetAttributeNS(namespace_url, name, value) abstract_self.unrooted().SetAttributeNS(namespace_url, name, value)
} }
// http://dom.spec.whatwg.org/#dom-element-removeattribute // http://dom.spec.whatwg.org/#dom-element-removeattribute
pub fn RemoveAttribute(&mut self, pub fn RemoveAttribute(&mut self,
abstract_self: &mut JS<Element>, abstract_self: &mut JSRef<Element>,
name: DOMString) -> ErrorResult { name: DOMString) -> ErrorResult {
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
}; };
abstract_self.remove_attribute(namespace::Null, name) abstract_self.unrooted().remove_attribute(namespace::Null, name)
} }
// http://dom.spec.whatwg.org/#dom-element-removeattributens // http://dom.spec.whatwg.org/#dom-element-removeattributens
pub fn RemoveAttributeNS(&mut self, pub fn RemoveAttributeNS(&mut self,
abstract_self: &mut JS<Element>, abstract_self: &mut JSRef<Element>,
namespace: Option<DOMString>, namespace: Option<DOMString>,
localname: DOMString) -> ErrorResult { localname: DOMString) -> ErrorResult {
let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace)); let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace));
abstract_self.remove_attribute(namespace, localname) abstract_self.unrooted().remove_attribute(namespace, localname)
} }
// http://dom.spec.whatwg.org/#dom-element-hasattribute // http://dom.spec.whatwg.org/#dom-element-hasattribute
pub fn HasAttribute(&self, abstract_self: &JS<Element>, pub fn HasAttribute(&self, abstract_self: &JSRef<Element>,
name: DOMString) -> bool { name: DOMString) -> bool {
self.GetAttribute(abstract_self, name).is_some() self.GetAttribute(abstract_self, name).is_some()
} }
// http://dom.spec.whatwg.org/#dom-element-hasattributens // http://dom.spec.whatwg.org/#dom-element-hasattributens
pub fn HasAttributeNS(&self, abstract_self: &JS<Element>, pub fn HasAttributeNS(&self, abstract_self: &JSRef<Element>,
namespace: Option<DOMString>, namespace: Option<DOMString>,
local_name: DOMString) -> bool { local_name: DOMString) -> bool {
self.GetAttributeNS(abstract_self, namespace, local_name).is_some() self.GetAttributeNS(abstract_self, namespace, local_name).is_some()
} }
pub fn GetElementsByTagName(&self, abstract_self: &JS<Element>, localname: DOMString) -> JS<HTMLCollection> { pub fn GetElementsByTagName(&self, abstract_self: &JSRef<Element>, localname: DOMString) -> JS<HTMLCollection> {
let roots = RootCollection::new();
let doc = self.node.owner_doc(); let doc = self.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
HTMLCollection::by_tag_name(&doc.window, &NodeCast::from(abstract_self), localname) let window = doc.window.root(&roots);
HTMLCollection::by_tag_name(&window.root_ref(), NodeCast::from_ref(abstract_self), localname)
} }
pub fn GetElementsByTagNameNS(&self, abstract_self: &JS<Element>, maybe_ns: Option<DOMString>, pub fn GetElementsByTagNameNS(&self, abstract_self: &JSRef<Element>, maybe_ns: Option<DOMString>,
localname: DOMString) -> JS<HTMLCollection> { localname: DOMString) -> JS<HTMLCollection> {
let roots = RootCollection::new();
let doc = self.node.owner_doc(); let doc = self.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
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
}; };
HTMLCollection::by_tag_name_ns(&doc.window, &NodeCast::from(abstract_self), localname, namespace) let window = doc.window.root(&roots);
HTMLCollection::by_tag_name_ns(&window.root_ref(), NodeCast::from_ref(abstract_self), localname, namespace)
} }
pub fn GetElementsByClassName(&self, abstract_self: &JS<Element>, classes: DOMString) -> JS<HTMLCollection> { pub fn GetElementsByClassName(&self, abstract_self: &JSRef<Element>, classes: DOMString) -> JS<HTMLCollection> {
let roots = RootCollection::new();
let doc = self.node.owner_doc(); let doc = self.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
HTMLCollection::by_class_name(&doc.window, &NodeCast::from(abstract_self), classes) let window = doc.window.root(&roots);
HTMLCollection::by_class_name(&window.root_ref(), NodeCast::from_ref(abstract_self), classes)
} }
// http://dev.w3.org/csswg/cssom-view/#dom-element-getclientrects // http://dev.w3.org/csswg/cssom-view/#dom-element-getclientrects
pub fn GetClientRects(&self, abstract_self: &JS<Element>) -> JS<ClientRectList> { pub fn GetClientRects(&self, abstract_self: &JSRef<Element>) -> JS<ClientRectList> {
let roots = RootCollection::new();
let doc = self.node.owner_doc(); let doc = self.node.owner_doc();
let win = &doc.get().window; let win = doc.get().window.root(&roots);
let node: JS<Node> = NodeCast::from(abstract_self); let node: JS<Node> = NodeCast::from(&abstract_self.unrooted());
let rects = node.get_content_boxes(); let rects = node.get_content_boxes();
let rects = rects.iter().map(|r| { let rects = rects.iter().map(|r| {
ClientRect::new( ClientRect::new(
win, &win.root_ref(),
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) r.origin.x + r.size.width)
}).collect(); }).collect();
ClientRectList::new(win, rects) ClientRectList::new(&win.root_ref(), rects)
} }
// http://dev.w3.org/csswg/cssom-view/#dom-element-getboundingclientrect // http://dev.w3.org/csswg/cssom-view/#dom-element-getboundingclientrect
pub fn GetBoundingClientRect(&self, abstract_self: &JS<Element>) -> JS<ClientRect> { pub fn GetBoundingClientRect(&self, abstract_self: &JSRef<Element>) -> JS<ClientRect> {
let roots = RootCollection::new();
let doc = self.node.owner_doc(); let doc = self.node.owner_doc();
let win = &doc.get().window; let win = doc.get().window.root(&roots);
let node: JS<Node> = NodeCast::from(abstract_self); let node: JS<Node> = NodeCast::from(&abstract_self.unrooted());
let rect = node.get_bounding_content_box(); let rect = node.get_bounding_content_box();
ClientRect::new( ClientRect::new(
win, &win.root_ref(),
rect.origin.y, rect.origin.y,
rect.origin.y + rect.size.height, rect.origin.y + rect.size.height,
rect.origin.x, rect.origin.x,
rect.origin.x + rect.size.width) rect.origin.x + rect.size.width)
} }
pub fn GetInnerHTML(&self, abstract_self: &JS<Element>) -> Fallible<DOMString> { pub fn GetInnerHTML(&self, abstract_self: &JSRef<Element>) -> Fallible<DOMString> {
//XXX TODO: XML case //XXX TODO: XML case
Ok(serialize(&mut NodeIterator::new(NodeCast::from(abstract_self), false, false))) Ok(serialize(&mut NodeIterator::new(NodeCast::from(&abstract_self.unrooted()), false, false)))
} }
pub fn GetOuterHTML(&self, abstract_self: &JS<Element>) -> Fallible<DOMString> { pub fn GetOuterHTML(&self, abstract_self: &JSRef<Element>) -> Fallible<DOMString> {
Ok(serialize(&mut NodeIterator::new(NodeCast::from(abstract_self), true, false))) Ok(serialize(&mut NodeIterator::new(NodeCast::from(&abstract_self.unrooted()), true, false)))
} }
pub fn Children(&self, abstract_self: &JS<Element>) -> JS<HTMLCollection> { pub fn Children(&self, abstract_self: &JSRef<Element>) -> JS<HTMLCollection> {
let doc = self.node.owner_doc(); let roots = RootCollection::new();
let doc = doc.get(); let window = window_from_node(&abstract_self.unrooted()).root(&roots);
HTMLCollection::children(&doc.window, &NodeCast::from(abstract_self)) HTMLCollection::children(&window.root_ref(), NodeCast::from_ref(abstract_self))
} }
} }
@ -667,6 +681,7 @@ impl VirtualMethods for JS<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()),
_ => (), _ => (),
@ -684,7 +699,8 @@ impl VirtualMethods for JS<Element> {
// "borrowed value does not live long enough" // "borrowed value does not live long enough"
let mut doc = node.get().owner_doc().clone(); let mut doc = node.get().owner_doc().clone();
let doc = doc.get_mut(); let doc = doc.get_mut();
doc.register_named_element(self, value.clone()); let elem = self.root(&roots);
doc.register_named_element(&elem.root_ref(), value.clone());
} }
_ => () _ => ()
} }
@ -693,6 +709,7 @@ impl VirtualMethods for JS<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()),
_ => (), _ => (),
@ -708,7 +725,8 @@ impl VirtualMethods for JS<Element> {
// "borrowed value does not live long enough" // "borrowed value does not live long enough"
let mut doc = node.get().owner_doc().clone(); let mut doc = node.get().owner_doc().clone();
let doc = doc.get_mut(); let doc = doc.get_mut();
doc.unregister_named_element(self, value); let elem = self.root(&roots);
doc.unregister_named_element(&elem.root_ref(), value);
} }
_ => () _ => ()
} }
@ -717,6 +735,7 @@ impl VirtualMethods for JS<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(),
_ => (), _ => (),
@ -725,13 +744,15 @@ impl VirtualMethods for JS<Element> {
match self.get_attribute(Null, "id") { match self.get_attribute(Null, "id") {
Some(attr) => { Some(attr) => {
let mut doc = document_from_node(self); let mut doc = document_from_node(self);
doc.get_mut().register_named_element(self, attr.get().Value()); let elem = self.root(&roots);
doc.get_mut().register_named_element(&elem.root_ref(), attr.get().Value());
} }
_ => () _ => ()
} }
} }
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(),
_ => (), _ => (),
@ -740,7 +761,8 @@ impl VirtualMethods for JS<Element> {
match self.get_attribute(Null, "id") { match self.get_attribute(Null, "id") {
Some(attr) => { Some(attr) => {
let mut doc = document_from_node(self); let mut doc = document_from_node(self);
doc.get_mut().unregister_named_element(self, attr.get().Value()); let elem = self.root(&roots);
doc.get_mut().unregister_named_element(&elem.root_ref(), attr.get().Value());
} }
_ => () _ => ()
} }

6
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; use dom::bindings::js::{JS, JSRef};
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;
@ -80,7 +80,7 @@ impl Event {
} }
} }
pub fn new(window: &JS<Window>) -> JS<Event> { pub fn new(window: &JSRef<Window>) -> JS<Event> {
reflect_dom_object(~Event::new_inherited(HTMLEventTypeId), reflect_dom_object(~Event::new_inherited(HTMLEventTypeId),
window, window,
EventBinding::Wrap) EventBinding::Wrap)
@ -155,7 +155,7 @@ impl Event {
self.trusted self.trusted
} }
pub fn Constructor(global: &JS<Window>, pub fn Constructor(global: &JSRef<Window>,
type_: DOMString, type_: DOMString,
init: &EventBinding::EventInit) -> Fallible<JS<Event>> { init: &EventBinding::EventInit) -> Fallible<JS<Event>> {
let mut ev = Event::new(global); let mut ev = Event::new(global);

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

@ -4,21 +4,23 @@
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::JS; use dom::bindings::js::{JS, JSRef};
use dom::eventtarget::{Capturing, Bubbling, EventTarget}; use dom::eventtarget::{Capturing, Bubbling, EventTarget};
use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing}; use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing};
use dom::node::{Node, NodeHelpers}; use dom::node::{Node, NodeHelpers};
// See http://dom.spec.whatwg.org/#concept-event-dispatch for the full dispatch algorithm // See http://dom.spec.whatwg.org/#concept-event-dispatch for the full dispatch algorithm
pub fn dispatch_event(target: &JS<EventTarget>, pub fn dispatch_event(target: &JSRef<EventTarget>,
pseudo_target: Option<JS<EventTarget>>, pseudo_target: Option<JSRef<EventTarget>>,
event: &mut JS<Event>) -> bool { event: &mut JSRef<Event>) -> bool {
assert!(!event.get().dispatching); assert!(!event.get().dispatching);
{ {
let event = event.get_mut(); let event = event.get_mut();
event.target = pseudo_target.or_else(|| { event.target = pseudo_target.map(|pseudo_target| {
Some(target.clone()) pseudo_target.unrooted()
}).or_else(|| {
Some(target.unrooted())
}); });
event.dispatching = true; event.dispatching = true;
} }
@ -27,7 +29,7 @@ pub fn dispatch_event(target: &JS<EventTarget>,
//TODO: no chain if not participating in a tree //TODO: no chain if not participating in a tree
let chain: Vec<JS<EventTarget>> = if target.get().is_node() { let chain: Vec<JS<EventTarget>> = if target.get().is_node() {
let target_node: JS<Node> = NodeCast::to(target).unwrap(); let target_node: JS<Node> = NodeCast::to(&target.unrooted()).unwrap();
target_node.ancestors().map(|ancestor| { target_node.ancestors().map(|ancestor| {
let ancestor_target: JS<EventTarget> = EventTargetCast::from(&ancestor); let ancestor_target: JS<EventTarget> = EventTargetCast::from(&ancestor);
ancestor_target ancestor_target
@ -70,7 +72,7 @@ pub fn dispatch_event(target: &JS<EventTarget>,
{ {
let event = event.get_mut(); let event = event.get_mut();
event.phase = PhaseAtTarget; event.phase = PhaseAtTarget;
event.current_target = Some(target.clone()); event.current_target = Some(target.unrooted());
} }
let opt_listeners = target.get().get_listeners(type_); let opt_listeners = target.get().get_listeners(type_);

12
src/components/script/dom/eventtarget.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; use dom::bindings::js::{JS, JSRef};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::bindings::error::{Fallible, InvalidState}; use dom::bindings::error::{Fallible, InvalidState};
use dom::bindings::codegen::BindingDeclarations::EventListenerBinding; use dom::bindings::codegen::BindingDeclarations::EventListenerBinding;
@ -102,15 +102,15 @@ impl EventTarget {
} }
} }
pub fn DispatchEvent(&self, abstract_self: &JS<EventTarget>, pub fn DispatchEvent(&self, abstract_self: &JSRef<EventTarget>,
event: &mut JS<Event>) -> Fallible<bool> { event: &mut JSRef<Event>) -> Fallible<bool> {
self.dispatch_event_with_target(abstract_self, None, event) self.dispatch_event_with_target(abstract_self, None, event)
} }
pub fn dispatch_event_with_target(&self, pub fn dispatch_event_with_target(&self,
abstract_self: &JS<EventTarget>, abstract_self: &JSRef<EventTarget>,
abstract_target: Option<JS<EventTarget>>, abstract_target: Option<JSRef<EventTarget>>,
event: &mut JS<Event>) -> Fallible<bool> { event: &mut JSRef<Event>) -> Fallible<bool> {
if event.get().dispatching || !event.get().initialized { if event.get().dispatching || !event.get().initialized {
return Err(InvalidState); return Err(InvalidState);
} }

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

@ -5,7 +5,7 @@
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::FormDataBinding; use dom::bindings::codegen::BindingDeclarations::FormDataBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::blob::Blob; use dom::blob::Blob;
use dom::htmlformelement::HTMLFormElement; use dom::htmlformelement::HTMLFormElement;
use dom::window::Window; use dom::window::Window;
@ -28,27 +28,27 @@ pub struct FormData {
} }
impl FormData { impl FormData {
pub fn new_inherited(form: Option<JS<HTMLFormElement>>, window: JS<Window>) -> FormData { pub fn new_inherited(form: Option<JSRef<HTMLFormElement>>, window: JS<Window>) -> FormData {
FormData { FormData {
data: HashMap::new(), data: HashMap::new(),
reflector_: Reflector::new(), reflector_: Reflector::new(),
window: window, window: window,
form: form form: form.map(|form| form.unrooted())
} }
} }
pub fn new(form: Option<JS<HTMLFormElement>>, window: &JS<Window>) -> JS<FormData> { pub fn new(form: Option<JSRef<HTMLFormElement>>, window: &JSRef<Window>) -> JS<FormData> {
reflect_dom_object(~FormData::new_inherited(form, window.clone()), window, FormDataBinding::Wrap) reflect_dom_object(~FormData::new_inherited(form, window.unrooted()), window, FormDataBinding::Wrap)
} }
pub fn Constructor(window: &JS<Window>, form: Option<JS<HTMLFormElement>>) pub fn Constructor(window: &JSRef<Window>, form: Option<JSRef<HTMLFormElement>>)
-> Fallible<JS<FormData>> { -> Fallible<JS<FormData>> {
Ok(FormData::new(form, window)) Ok(FormData::new(form, window))
} }
pub fn Append(&mut self, name: DOMString, value: &JS<Blob>, filename: Option<DOMString>) { pub fn Append(&mut self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>) {
let blob = BlobData { let blob = BlobData {
blob: value.clone(), blob: value.unrooted(),
name: filename.unwrap_or(~"default") name: filename.unwrap_or(~"default")
}; };
self.data.insert(name.clone(), blob); self.data.insert(name.clone(), blob);

6
src/components/script/dom/htmlanchorelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLAnchorElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLAnchorElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLAnchorElementDerived; use dom::bindings::codegen::InheritTypes::HTMLAnchorElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLAnchorElementTypeId; use dom::element::HTMLAnchorElementTypeId;
@ -34,8 +34,8 @@ impl HTMLAnchorElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLAnchorElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLAnchorElement> {
let element = HTMLAnchorElement::new_inherited(localName, document.clone()); let element = HTMLAnchorElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLAnchorElementBinding::Wrap) Node::reflect_node(~element, document, HTMLAnchorElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlappletelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLAppletElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLAppletElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLAppletElementDerived; use dom::bindings::codegen::InheritTypes::HTMLAppletElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLAppletElementTypeId; use dom::element::HTMLAppletElementTypeId;
@ -34,8 +34,8 @@ impl HTMLAppletElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLAppletElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLAppletElement> {
let element = HTMLAppletElement::new_inherited(localName, document.clone()); let element = HTMLAppletElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLAppletElementBinding::Wrap) Node::reflect_node(~element, document, HTMLAppletElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlareaelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLAreaElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLAreaElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLAreaElementDerived; use dom::bindings::codegen::InheritTypes::HTMLAreaElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLAreaElementTypeId; use dom::element::HTMLAreaElementTypeId;
@ -34,8 +34,8 @@ impl HTMLAreaElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLAreaElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLAreaElement> {
let element = HTMLAreaElement::new_inherited(localName, document.clone()); let element = HTMLAreaElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLAreaElementBinding::Wrap) Node::reflect_node(~element, document, HTMLAreaElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlaudioelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLAudioElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLAudioElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLAudioElementDerived; use dom::bindings::codegen::InheritTypes::HTMLAudioElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLAudioElementTypeId; use dom::element::HTMLAudioElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLAudioElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLAudioElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLAudioElement> {
let element = HTMLAudioElement::new_inherited(localName, document.clone()); let element = HTMLAudioElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLAudioElementBinding::Wrap) Node::reflect_node(~element, document, HTMLAudioElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlbaseelement.rs
View file

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLBaseElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLBaseElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLBaseElementDerived; use dom::bindings::codegen::InheritTypes::HTMLBaseElementDerived;
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLBaseElementTypeId; use dom::element::HTMLBaseElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -34,8 +34,8 @@ impl HTMLBaseElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLBaseElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLBaseElement> {
let element = HTMLBaseElement::new_inherited(localName, document.clone()); let element = HTMLBaseElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLBaseElementBinding::Wrap) Node::reflect_node(~element, document, HTMLBaseElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlbodyelement.rs
View file

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLBodyElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLBodyElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLBodyElementDerived; use dom::bindings::codegen::InheritTypes::HTMLBodyElementDerived;
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLBodyElementTypeId; use dom::element::HTMLBodyElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -34,8 +34,8 @@ impl HTMLBodyElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLBodyElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLBodyElement> {
let element = HTMLBodyElement::new_inherited(localName, document.clone()); let element = HTMLBodyElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLBodyElementBinding::Wrap) Node::reflect_node(~element, document, HTMLBodyElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlbrelement.rs
View file

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLBRElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLBRElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLBRElementDerived; use dom::bindings::codegen::InheritTypes::HTMLBRElementDerived;
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLBRElementTypeId; use dom::element::HTMLBRElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -34,8 +34,8 @@ impl HTMLBRElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLBRElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLBRElement> {
let element = HTMLBRElement::new_inherited(localName, document.clone()); let element = HTMLBRElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLBRElementBinding::Wrap) Node::reflect_node(~element, document, HTMLBRElementBinding::Wrap)
} }
} }

9
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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;
@ -36,8 +36,8 @@ impl HTMLButtonElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLButtonElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLButtonElement> {
let element = HTMLButtonElement::new_inherited(localName, document.clone()); let element = HTMLButtonElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLButtonElementBinding::Wrap) Node::reflect_node(~element, document, HTMLButtonElementBinding::Wrap)
} }
} }
@ -135,9 +135,10 @@ impl HTMLButtonElement {
} }
pub fn Validity(&self) -> JS<ValidityState> { pub fn Validity(&self) -> JS<ValidityState> {
let roots = RootCollection::new();
let doc = self.htmlelement.element.node.owner_doc(); let doc = self.htmlelement.element.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
ValidityState::new(&doc.window) ValidityState::new(&doc.window.root(&roots).root_ref())
} }
pub fn SetValidity(&mut self, _validity: JS<ValidityState>) { pub fn SetValidity(&mut self, _validity: JS<ValidityState>) {

6
src/components/script/dom/htmlcanvaselement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLCanvasElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLCanvasElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLCanvasElementDerived; use dom::bindings::codegen::InheritTypes::HTMLCanvasElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::{ErrorResult}; use dom::bindings::error::{ErrorResult};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLCanvasElementTypeId; use dom::element::HTMLCanvasElementTypeId;
@ -34,8 +34,8 @@ impl HTMLCanvasElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLCanvasElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLCanvasElement> {
let element = HTMLCanvasElement::new_inherited(localName, document.clone()); let element = HTMLCanvasElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLCanvasElementBinding::Wrap) Node::reflect_node(~element, document, HTMLCanvasElementBinding::Wrap)
} }
} }

85
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -15,7 +15,7 @@ use servo_util::str::{DOMString, split_html_space_chars};
use serialize::{Encoder, Encodable}; use serialize::{Encoder, Encodable};
pub trait CollectionFilter { pub trait CollectionFilter {
fn filter(&self, elem: &JS<Element>, root: &JS<Node>) -> bool; fn filter(&self, elem: &JSRef<Element>, root: &JSRef<Node>) -> bool;
} }
impl<S: Encoder<E>, E> Encodable<S, E> for ~CollectionFilter { impl<S: Encoder<E>, E> Encodable<S, E> for ~CollectionFilter {
@ -46,24 +46,24 @@ impl HTMLCollection {
} }
} }
pub fn new(window: &JS<Window>, collection: CollectionTypeId) -> JS<HTMLCollection> { pub fn new(window: &JSRef<Window>, collection: CollectionTypeId) -> JS<HTMLCollection> {
reflect_dom_object(~HTMLCollection::new_inherited(window.clone(), collection), reflect_dom_object(~HTMLCollection::new_inherited(window.unrooted(), collection),
window, HTMLCollectionBinding::Wrap) window, HTMLCollectionBinding::Wrap)
} }
} }
impl HTMLCollection { impl HTMLCollection {
pub fn create(window: &JS<Window>, root: &JS<Node>, filter: ~CollectionFilter) -> JS<HTMLCollection> { pub fn create(window: &JSRef<Window>, root: &JSRef<Node>, filter: ~CollectionFilter) -> JS<HTMLCollection> {
HTMLCollection::new(window, Live(root.clone(), filter)) HTMLCollection::new(window, Live(root.unrooted(), filter))
} }
pub fn by_tag_name(window: &JS<Window>, root: &JS<Node>, tag: DOMString) pub fn by_tag_name(window: &JSRef<Window>, root: &JSRef<Node>, tag: DOMString)
-> JS<HTMLCollection> { -> JS<HTMLCollection> {
struct TagNameFilter { struct TagNameFilter {
tag: DOMString tag: DOMString
} }
impl CollectionFilter for TagNameFilter { impl CollectionFilter for TagNameFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == self.tag elem.get().local_name == self.tag
} }
} }
@ -73,14 +73,14 @@ impl HTMLCollection {
HTMLCollection::create(window, root, ~filter) HTMLCollection::create(window, root, ~filter)
} }
pub fn by_tag_name_ns(window: &JS<Window>, root: &JS<Node>, tag: DOMString, pub fn by_tag_name_ns(window: &JSRef<Window>, root: &JSRef<Node>, tag: DOMString,
namespace: Namespace) -> JS<HTMLCollection> { namespace: Namespace) -> JS<HTMLCollection> {
struct TagNameNSFilter { struct TagNameNSFilter {
tag: DOMString, tag: DOMString,
namespace: Namespace namespace: Namespace
} }
impl CollectionFilter for TagNameNSFilter { impl CollectionFilter for TagNameNSFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().namespace == self.namespace && elem.get().local_name == self.tag elem.get().namespace == self.namespace && elem.get().local_name == self.tag
} }
} }
@ -91,14 +91,14 @@ impl HTMLCollection {
HTMLCollection::create(window, root, ~filter) HTMLCollection::create(window, root, ~filter)
} }
pub fn by_class_name(window: &JS<Window>, root: &JS<Node>, classes: DOMString) pub fn by_class_name(window: &JSRef<Window>, root: &JSRef<Node>, classes: DOMString)
-> JS<HTMLCollection> { -> JS<HTMLCollection> {
struct ClassNameFilter { struct ClassNameFilter {
classes: Vec<DOMString> classes: Vec<DOMString>
} }
impl CollectionFilter for ClassNameFilter { impl CollectionFilter for ClassNameFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
self.classes.iter().all(|class| elem.has_class(*class)) self.classes.iter().all(|class| elem.unrooted().has_class(*class))
} }
} }
let filter = ClassNameFilter { let filter = ClassNameFilter {
@ -107,11 +107,11 @@ impl HTMLCollection {
HTMLCollection::create(window, root, ~filter) HTMLCollection::create(window, root, ~filter)
} }
pub fn children(window: &JS<Window>, root: &JS<Node>) -> JS<HTMLCollection> { pub fn children(window: &JSRef<Window>, root: &JSRef<Node>) -> JS<HTMLCollection> {
struct ElementChildFilter; struct ElementChildFilter;
impl CollectionFilter for ElementChildFilter { impl CollectionFilter for ElementChildFilter {
fn filter(&self, elem: &JS<Element>, root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, root: &JSRef<Node>) -> bool {
root.is_parent_of(&NodeCast::from(elem)) root.unrooted().is_parent_of(NodeCast::from_ref(elem))
} }
} }
HTMLCollection::create(window, root, ~ElementChildFilter) HTMLCollection::create(window, root, ~ElementChildFilter)
@ -121,32 +121,47 @@ impl HTMLCollection {
impl HTMLCollection { impl HTMLCollection {
// http://dom.spec.whatwg.org/#dom-htmlcollection-length // http://dom.spec.whatwg.org/#dom-htmlcollection-length
pub fn Length(&self) -> u32 { pub 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) => root.traverse_preorder() Live(ref root, ref filter) => {
.count(|child| { let root_root = root.root(&roots);
let elem: Option<JS<Element>> = ElementCast::to(&child); root.traverse_preorder()
elem.map_or(false, |elem| filter.filter(&elem, root)) .count(|child| {
}) as u32 let elem: Option<JS<Element>> = ElementCast::to(&child);
elem.map_or(false, |elem| {
let elem = elem.root(&roots);
filter.filter(&elem.root_ref(), &root_root.root_ref())
})
}) as u32
}
} }
} }
// http://dom.spec.whatwg.org/#dom-htmlcollection-item // http://dom.spec.whatwg.org/#dom-htmlcollection-item
pub fn Item(&self, index: u32) -> Option<JS<Element>> { pub fn Item(&self, index: u32) -> Option<JS<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| elem.clone()), .map(|elem| elem.clone()),
Live(ref root, ref filter) => root.traverse_preorder() Live(ref root, ref filter) => {
.filter_map(|node| ElementCast::to(&node)) let root_root = root.root(&roots);
.filter(|elem| filter.filter(elem, root)) root.traverse_preorder()
.nth(index as uint).clone() .filter_map(|node| ElementCast::to(&node))
.filter(|elem| {
let elem = elem.root(&roots);
filter.filter(&elem.root_ref(), &root_root.root_ref())
})
.nth(index as uint).clone()
}
} }
} }
// http://dom.spec.whatwg.org/#dom-htmlcollection-nameditem // http://dom.spec.whatwg.org/#dom-htmlcollection-nameditem
pub fn NamedItem(&self, key: DOMString) -> Option<JS<Element>> { pub fn NamedItem(&self, key: DOMString) -> Option<JS<Element>> {
let roots = RootCollection::new();
// Step 1. // Step 1.
if key.is_empty() { if key.is_empty() {
return None; return None;
@ -159,13 +174,19 @@ impl HTMLCollection {
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| maybe_elem.clone()), .map(|maybe_elem| maybe_elem.clone()),
Live(ref root, ref filter) => root.traverse_preorder() Live(ref root, ref filter) => {
.filter_map(|node| ElementCast::to(&node)) let root_root = root.root(&roots);
.filter(|elem| filter.filter(elem, root)) root.traverse_preorder()
.find(|elem| { .filter_map(|node| ElementCast::to(&node))
elem.get_string_attribute("name") == key || .filter(|elem| {
elem.get_string_attribute("id") == key }) let elem = elem.root(&roots);
.map(|maybe_elem| maybe_elem.clone()) filter.filter(&elem.root_ref(), &root_root.root_ref())
})
.find(|elem| {
elem.get_string_attribute("name") == key ||
elem.get_string_attribute("id") == key })
.map(|maybe_elem| maybe_elem.clone())
}
} }
} }
} }

6
src/components/script/dom/htmldataelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLDataElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLDataElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLDataElementDerived; use dom::bindings::codegen::InheritTypes::HTMLDataElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLDataElementTypeId; use dom::element::HTMLDataElementTypeId;
@ -34,8 +34,8 @@ impl HTMLDataElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLDataElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLDataElement> {
let element = HTMLDataElement::new_inherited(localName, document.clone()); let element = HTMLDataElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLDataElementBinding::Wrap) Node::reflect_node(~element, document, HTMLDataElementBinding::Wrap)
} }
} }

16
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -34,22 +34,24 @@ impl HTMLDataListElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLDataListElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLDataListElement> {
let element = HTMLDataListElement::new_inherited(localName, document.clone()); let element = HTMLDataListElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLDataListElementBinding::Wrap) Node::reflect_node(~element, document, HTMLDataListElementBinding::Wrap)
} }
} }
impl HTMLDataListElement { impl HTMLDataListElement {
pub fn Options(&self, abstract_self: &JS<HTMLDataListElement>) -> JS<HTMLCollection> { pub fn Options(&self, abstract_self: &JSRef<HTMLDataListElement>) -> JS<HTMLCollection> {
struct HTMLDataListOptionsFilter; struct HTMLDataListOptionsFilter;
impl CollectionFilter for HTMLDataListOptionsFilter { impl CollectionFilter for HTMLDataListOptionsFilter {
fn filter(&self, elem: &JS<Element>, _root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
elem.get().local_name == ~"option" elem.get().local_name == ~"option"
} }
} }
let node: JS<Node> = NodeCast::from(abstract_self); let roots = RootCollection::new();
let node: &JSRef<Node> = NodeCast::from_ref(abstract_self);
let filter = ~HTMLDataListOptionsFilter; let filter = ~HTMLDataListOptionsFilter;
HTMLCollection::create(&window_from_node(&node), &node, filter) let window = window_from_node(&node.unrooted()).root(&roots);
HTMLCollection::create(&window.root_ref(), node, filter)
} }
} }

6
src/components/script/dom/htmldirectoryelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLDirectoryElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLDirectoryElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLDirectoryElementDerived; use dom::bindings::codegen::InheritTypes::HTMLDirectoryElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLDirectoryElementTypeId; use dom::element::HTMLDirectoryElementTypeId;
@ -34,8 +34,8 @@ impl HTMLDirectoryElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLDirectoryElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLDirectoryElement> {
let element = HTMLDirectoryElement::new_inherited(localName, document.clone()); let element = HTMLDirectoryElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLDirectoryElementBinding::Wrap) Node::reflect_node(~element, document, HTMLDirectoryElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmldivelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLDivElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLDivElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLDivElementDerived; use dom::bindings::codegen::InheritTypes::HTMLDivElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLDivElementTypeId; use dom::element::HTMLDivElementTypeId;
@ -34,8 +34,8 @@ impl HTMLDivElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLDivElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLDivElement> {
let element = HTMLDivElement::new_inherited(localName, document.clone()); let element = HTMLDivElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLDivElementBinding::Wrap) Node::reflect_node(~element, document, HTMLDivElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmldlistelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLDListElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLDListElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLDListElementDerived; use dom::bindings::codegen::InheritTypes::HTMLDListElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLDListElementTypeId; use dom::element::HTMLDListElementTypeId;
@ -34,8 +34,8 @@ impl HTMLDListElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLDListElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLDListElement> {
let element = HTMLDListElement::new_inherited(localName, document.clone()); let element = HTMLDListElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLDListElementBinding::Wrap) Node::reflect_node(~element, document, HTMLDListElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlelement.rs
View file

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLElementBinding;
use dom::bindings::codegen::InheritTypes::ElementCast; use dom::bindings::codegen::InheritTypes::ElementCast;
use dom::bindings::codegen::InheritTypes::HTMLElementDerived; use dom::bindings::codegen::InheritTypes::HTMLElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::{ErrorResult, Fallible}; use dom::bindings::error::{ErrorResult, Fallible};
use dom::document::Document; use dom::document::Document;
use dom::element::{Element, ElementTypeId, HTMLElementTypeId}; use dom::element::{Element, ElementTypeId, HTMLElementTypeId};
@ -39,8 +39,8 @@ impl HTMLElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLElement> {
let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, document.clone()); let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, document.unrooted());
Node::reflect_node(~element, document, HTMLElementBinding::Wrap) Node::reflect_node(~element, document, HTMLElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlembedelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLEmbedElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLEmbedElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLEmbedElementDerived; use dom::bindings::codegen::InheritTypes::HTMLEmbedElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLEmbedElementTypeId; use dom::element::HTMLEmbedElementTypeId;
@ -34,8 +34,8 @@ impl HTMLEmbedElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLEmbedElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLEmbedElement> {
let element = HTMLEmbedElement::new_inherited(localName, document.clone()); let element = HTMLEmbedElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLEmbedElementBinding::Wrap) Node::reflect_node(~element, document, HTMLEmbedElementBinding::Wrap)
} }
} }

24
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -37,8 +37,8 @@ impl HTMLFieldSetElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLFieldSetElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLFieldSetElement> {
let element = HTMLFieldSetElement::new_inherited(localName, document.clone()); let element = HTMLFieldSetElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLFieldSetElementBinding::Wrap) Node::reflect_node(~element, document, HTMLFieldSetElementBinding::Wrap)
} }
} }
@ -69,19 +69,21 @@ impl HTMLFieldSetElement {
} }
// http://www.whatwg.org/html/#dom-fieldset-elements // http://www.whatwg.org/html/#dom-fieldset-elements
pub fn Elements(&self, abstract_self: &JS<HTMLFieldSetElement>) -> JS<HTMLCollection> { pub fn Elements(&self, abstract_self: &JSRef<HTMLFieldSetElement>) -> JS<HTMLCollection> {
struct ElementsFilter; struct ElementsFilter;
impl CollectionFilter for ElementsFilter { impl CollectionFilter for ElementsFilter {
fn filter(&self, elem: &JS<Element>, root: &JS<Node>) -> bool { fn filter(&self, elem: &JSRef<Element>, root: &JSRef<Node>) -> bool {
static tag_names: StaticStringVec = &["button", "fieldset", "input", static tag_names: StaticStringVec = &["button", "fieldset", "input",
"keygen", "object", "output", "select", "textarea"]; "keygen", "object", "output", "select", "textarea"];
let root: &JS<Element> = &ElementCast::to(root).unwrap(); let root: &JS<Element> = &ElementCast::to(&root.unrooted()).unwrap();
elem != root && tag_names.iter().any(|&tag_name| tag_name == elem.get().local_name) &elem.unrooted() != root && tag_names.iter().any(|&tag_name| tag_name == elem.get().local_name)
} }
} }
let node: JS<Node> = NodeCast::from(abstract_self); let roots = RootCollection::new();
let node: &JSRef<Node> = NodeCast::from_ref(abstract_self);
let filter = ~ElementsFilter; let filter = ~ElementsFilter;
HTMLCollection::create(&window_from_node(&node), &node, filter) let window = window_from_node(&node.unrooted()).root(&roots);
HTMLCollection::create(&window.root_ref(), node, filter)
} }
pub fn WillValidate(&self) -> bool { pub fn WillValidate(&self) -> bool {
@ -89,9 +91,11 @@ impl HTMLFieldSetElement {
} }
pub fn Validity(&self) -> JS<ValidityState> { pub fn Validity(&self) -> JS<ValidityState> {
let roots = RootCollection::new();
let doc = self.htmlelement.element.node.owner_doc(); let doc = self.htmlelement.element.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
ValidityState::new(&doc.window) let window = doc.window.root(&roots);
ValidityState::new(&window.root_ref())
} }
pub fn ValidationMessage(&self) -> DOMString { pub fn ValidationMessage(&self) -> DOMString {

6
src/components/script/dom/htmlfontelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLFontElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLFontElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLFontElementDerived; use dom::bindings::codegen::InheritTypes::HTMLFontElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLFontElementTypeId; use dom::element::HTMLFontElementTypeId;
@ -34,8 +34,8 @@ impl HTMLFontElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLFontElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLFontElement> {
let element = HTMLFontElement::new_inherited(localName, document.clone()); let element = HTMLFontElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLFontElementBinding::Wrap) Node::reflect_node(~element, document, HTMLFontElementBinding::Wrap)
} }
} }

10
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -35,8 +35,8 @@ impl HTMLFormElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLFormElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLFormElement> {
let element = HTMLFormElement::new_inherited(localName, document.clone()); let element = HTMLFormElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLFormElementBinding::Wrap) Node::reflect_node(~element, document, HTMLFormElementBinding::Wrap)
} }
} }
@ -116,9 +116,11 @@ impl HTMLFormElement {
pub fn Elements(&self) -> JS<HTMLCollection> { pub fn Elements(&self) -> JS<HTMLCollection> {
// FIXME: https://github.com/mozilla/servo/issues/1844 // FIXME: https://github.com/mozilla/servo/issues/1844
let roots = RootCollection::new();
let doc = self.htmlelement.element.node.owner_doc(); let doc = self.htmlelement.element.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
HTMLCollection::new(&doc.window, Static(vec!())) let window = doc.window.root(&roots);
HTMLCollection::new(&window.root_ref(), Static(vec!()))
} }
pub fn Length(&self) -> i32 { pub fn Length(&self) -> i32 {

6
src/components/script/dom/htmlframeelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLFrameElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLFrameElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLFrameElementDerived; use dom::bindings::codegen::InheritTypes::HTMLFrameElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLFrameElementTypeId; use dom::element::HTMLFrameElementTypeId;
@ -35,8 +35,8 @@ impl HTMLFrameElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLFrameElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLFrameElement> {
let element = HTMLFrameElement::new_inherited(localName, document.clone()); let element = HTMLFrameElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLFrameElementBinding::Wrap) Node::reflect_node(~element, document, HTMLFrameElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlframesetelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLFrameSetElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLFrameSetElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLFrameSetElementDerived; use dom::bindings::codegen::InheritTypes::HTMLFrameSetElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLFrameSetElementTypeId; use dom::element::HTMLFrameSetElementTypeId;
@ -34,8 +34,8 @@ impl HTMLFrameSetElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLFrameSetElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLFrameSetElement> {
let element = HTMLFrameSetElement::new_inherited(localName, document.clone()); let element = HTMLFrameSetElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLFrameSetElementBinding::Wrap) Node::reflect_node(~element, document, HTMLFrameSetElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlheadelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLHeadElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLHeadElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLHeadElementDerived; use dom::bindings::codegen::InheritTypes::HTMLHeadElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLHeadElementTypeId; use dom::element::HTMLHeadElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLHeadElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLHeadElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLHeadElement> {
let element = HTMLHeadElement::new_inherited(localName, document.clone()); let element = HTMLHeadElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLHeadElementBinding::Wrap) Node::reflect_node(~element, document, HTMLHeadElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlheadingelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLHeadingElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLHeadingElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLHeadingElementDerived; use dom::bindings::codegen::InheritTypes::HTMLHeadingElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLHeadingElementTypeId; use dom::element::HTMLHeadingElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -45,8 +45,8 @@ impl HTMLHeadingElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>, level: HeadingLevel) -> JS<HTMLHeadingElement> { pub fn new(localName: DOMString, document: &JSRef<Document>, level: HeadingLevel) -> JS<HTMLHeadingElement> {
let element = HTMLHeadingElement::new_inherited(localName, document.clone(), level); let element = HTMLHeadingElement::new_inherited(localName, document.unrooted(), level);
Node::reflect_node(~element, document, HTMLHeadingElementBinding::Wrap) Node::reflect_node(~element, document, HTMLHeadingElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlhrelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLHRElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLHRElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLHRElementDerived; use dom::bindings::codegen::InheritTypes::HTMLHRElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLHRElementTypeId; use dom::element::HTMLHRElementTypeId;
@ -34,8 +34,8 @@ impl HTMLHRElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLHRElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLHRElement> {
let element = HTMLHRElement::new_inherited(localName, document.clone()); let element = HTMLHRElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLHRElementBinding::Wrap) Node::reflect_node(~element, document, HTMLHRElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlhtmlelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLHtmlElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLHtmlElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLHtmlElementDerived; use dom::bindings::codegen::InheritTypes::HTMLHtmlElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLHtmlElementTypeId; use dom::element::HTMLHtmlElementTypeId;
@ -34,8 +34,8 @@ impl HTMLHtmlElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLHtmlElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLHtmlElement> {
let element = HTMLHtmlElement::new_inherited(localName, document.clone()); let element = HTMLHtmlElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLHtmlElementBinding::Wrap) Node::reflect_node(~element, document, HTMLHtmlElementBinding::Wrap)
} }
} }

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLIFrameElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLIFrameElementBinding;
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLIFrameElementDerived, HTMLElementCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLIFrameElementDerived, HTMLElementCast};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::trace::Untraceable; use dom::bindings::trace::Untraceable;
use dom::document::Document; use dom::document::Document;
use dom::element::{HTMLIFrameElementTypeId, Element}; use dom::element::{HTMLIFrameElementTypeId, Element};
@ -74,8 +74,8 @@ impl HTMLIFrameElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLIFrameElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLIFrameElement> {
let element = HTMLIFrameElement::new_inherited(localName, document.clone()); let element = HTMLIFrameElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLIFrameElementBinding::Wrap) Node::reflect_node(~element, document, HTMLIFrameElementBinding::Wrap)
} }
} }
@ -105,13 +105,13 @@ impl HTMLIFrameElement {
Ok(()) Ok(())
} }
pub fn Sandbox(&self, abstract_self: &JS<HTMLIFrameElement>) -> DOMString { pub fn Sandbox(&self, abstract_self: &JSRef<HTMLIFrameElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("sandbox") element.get_string_attribute("sandbox")
} }
pub fn SetSandbox(&mut self, abstract_self: &mut JS<HTMLIFrameElement>, sandbox: DOMString) { pub fn SetSandbox(&mut self, abstract_self: &mut JSRef<HTMLIFrameElement>, sandbox: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("sandbox", sandbox); element.set_string_attribute("sandbox", sandbox);
} }

102
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; use dom::bindings::js::{JS, JSRef};
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,8 +43,8 @@ impl HTMLImageElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLImageElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLImageElement> {
let element = HTMLImageElement::new_inherited(localName, document.clone()); let element = HTMLImageElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLImageElementBinding::Wrap) Node::reflect_node(~element, document, HTMLImageElementBinding::Wrap)
} }
} }
@ -79,23 +79,23 @@ impl HTMLImageElement {
} }
} }
pub fn Alt(&self, abstract_self: &JS<HTMLImageElement>) -> DOMString { pub fn Alt(&self, abstract_self: &JSRef<HTMLImageElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("alt") element.get_string_attribute("alt")
} }
pub fn SetAlt(&mut self, abstract_self: &JS<HTMLImageElement>, alt: DOMString) { pub fn SetAlt(&mut self, abstract_self: &JSRef<HTMLImageElement>, alt: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("alt", alt) element.set_string_attribute("alt", alt)
} }
pub fn Src(&self, abstract_self: &JS<HTMLImageElement>) -> DOMString { pub fn Src(&self, abstract_self: &JSRef<HTMLImageElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("src") element.get_string_attribute("src")
} }
pub fn SetSrc(&mut self, abstract_self: &mut JS<HTMLImageElement>, src: DOMString) { pub fn SetSrc(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, src: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_url_attribute("src", src) element.set_url_attribute("src", src)
} }
@ -107,45 +107,45 @@ impl HTMLImageElement {
Ok(()) Ok(())
} }
pub fn UseMap(&self, abstract_self: &JS<HTMLImageElement>) -> DOMString { pub fn UseMap(&self, abstract_self: &JSRef<HTMLImageElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("useMap") element.get_string_attribute("useMap")
} }
pub fn SetUseMap(&mut self, abstract_self: &mut JS<HTMLImageElement>, use_map: DOMString) { pub fn SetUseMap(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, use_map: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("useMap", use_map) element.set_string_attribute("useMap", use_map)
} }
pub fn IsMap(&self, abstract_self: &JS<HTMLImageElement>) -> bool { pub fn IsMap(&self, abstract_self: &JSRef<HTMLImageElement>) -> bool {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
from_str::<bool>(element.get_string_attribute("hspace")).unwrap() from_str::<bool>(element.get_string_attribute("hspace")).unwrap()
} }
pub fn SetIsMap(&self, abstract_self: &mut JS<HTMLImageElement>, is_map: bool) { pub fn SetIsMap(&self, abstract_self: &mut JSRef<HTMLImageElement>, is_map: bool) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("isMap", is_map.to_str()) element.set_string_attribute("isMap", is_map.to_str())
} }
pub fn Width(&self, abstract_self: &JS<HTMLImageElement>) -> u32 { pub fn Width(&self, abstract_self: &JSRef<HTMLImageElement>) -> u32 {
let node: JS<Node> = NodeCast::from(abstract_self); let node: JS<Node> = NodeCast::from(&abstract_self.unrooted());
let rect = node.get_bounding_content_box(); let rect = node.get_bounding_content_box();
to_px(rect.size.width) as u32 to_px(rect.size.width) as u32
} }
pub fn SetWidth(&mut self, abstract_self: &JS<HTMLImageElement>, width: u32) { pub fn SetWidth(&mut self, abstract_self: &JSRef<HTMLImageElement>, width: u32) {
let mut elem: JS<Element> = ElementCast::from(abstract_self); let mut elem: JS<Element> = ElementCast::from(&abstract_self.unrooted());
elem.set_uint_attribute("width", width) elem.set_uint_attribute("width", width)
} }
pub fn Height(&self, abstract_self: &JS<HTMLImageElement>) -> u32 { pub fn Height(&self, abstract_self: &JSRef<HTMLImageElement>) -> u32 {
let node: JS<Node> = NodeCast::from(abstract_self); let node: JS<Node> = NodeCast::from(&abstract_self.unrooted());
let rect = node.get_bounding_content_box(); let rect = node.get_bounding_content_box();
to_px(rect.size.height) as u32 to_px(rect.size.height) as u32
} }
pub fn SetHeight(&mut self, abstract_self: &JS<HTMLImageElement>, height: u32) { pub fn SetHeight(&mut self, abstract_self: &JSRef<HTMLImageElement>, height: u32) {
let mut elem: JS<Element> = ElementCast::from(abstract_self); let mut elem: JS<Element> = ElementCast::from(&abstract_self.unrooted());
elem.set_uint_attribute("height", height) elem.set_uint_attribute("height", height)
} }
@ -161,63 +161,63 @@ impl HTMLImageElement {
false false
} }
pub fn Name(&self, abstract_self: &JS<HTMLImageElement>) -> DOMString { pub fn Name(&self, abstract_self: &JSRef<HTMLImageElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("name") element.get_string_attribute("name")
} }
pub fn SetName(&mut self, abstract_self: &mut JS<HTMLImageElement>, name: DOMString) { pub fn SetName(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, name: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("name", name) element.set_string_attribute("name", name)
} }
pub fn Align(&self, abstract_self: &JS<HTMLImageElement>) -> DOMString { pub fn Align(&self, abstract_self: &JSRef<HTMLImageElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("longdesc") element.get_string_attribute("longdesc")
} }
pub fn SetAlign(&mut self, abstract_self: &mut JS<HTMLImageElement>, align: DOMString) { pub fn SetAlign(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, align: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("align", align) element.set_string_attribute("align", align)
} }
pub fn Hspace(&self, abstract_self: &JS<HTMLImageElement>) -> u32 { pub fn Hspace(&self, abstract_self: &JSRef<HTMLImageElement>) -> u32 {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
from_str::<u32>(element.get_string_attribute("hspace")).unwrap() from_str::<u32>(element.get_string_attribute("hspace")).unwrap()
} }
pub fn SetHspace(&mut self, abstract_self: &mut JS<HTMLImageElement>, hspace: u32) { pub fn SetHspace(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, hspace: u32) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_uint_attribute("hspace", hspace) element.set_uint_attribute("hspace", hspace)
} }
pub fn Vspace(&self, abstract_self: &JS<HTMLImageElement>) -> u32 { pub fn Vspace(&self, abstract_self: &JSRef<HTMLImageElement>) -> u32 {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
from_str::<u32>(element.get_string_attribute("vspace")).unwrap() from_str::<u32>(element.get_string_attribute("vspace")).unwrap()
} }
pub fn SetVspace(&mut self, abstract_self: &mut JS<HTMLImageElement>, vspace: u32) { pub fn SetVspace(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, vspace: u32) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_uint_attribute("vspace", vspace) element.set_uint_attribute("vspace", vspace)
} }
pub fn LongDesc(&self, abstract_self: &JS<HTMLImageElement>) -> DOMString { pub fn LongDesc(&self, abstract_self: &JSRef<HTMLImageElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("longdesc") element.get_string_attribute("longdesc")
} }
pub fn SetLongDesc(&mut self, abstract_self: &mut JS<HTMLImageElement>, longdesc: DOMString) { pub fn SetLongDesc(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, longdesc: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("longdesc", longdesc) element.set_string_attribute("longdesc", longdesc)
} }
pub fn Border(&self, abstract_self: &JS<HTMLImageElement>) -> DOMString { pub fn Border(&self, abstract_self: &JSRef<HTMLImageElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_string_attribute("border") element.get_string_attribute("border")
} }
pub fn SetBorder(&mut self, abstract_self: &mut JS<HTMLImageElement>, border: DOMString) { pub fn SetBorder(&mut self, abstract_self: &mut JSRef<HTMLImageElement>, border: DOMString) {
let mut element: JS<Element> = ElementCast::from(abstract_self); let mut element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.set_string_attribute("border", border) element.set_string_attribute("border", border)
} }
} }

6
src/components/script/dom/htmlinputelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLInputElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLInputElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLInputElementDerived; use dom::bindings::codegen::InheritTypes::HTMLInputElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::{ErrorResult, Fallible}; use dom::bindings::error::{ErrorResult, Fallible};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLInputElementTypeId; use dom::element::HTMLInputElementTypeId;
@ -34,8 +34,8 @@ impl HTMLInputElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLInputElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLInputElement> {
let element = HTMLInputElement::new_inherited(localName, document.clone()); let element = HTMLInputElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLInputElementBinding::Wrap) Node::reflect_node(~element, document, HTMLInputElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmllabelelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLLabelElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLLabelElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLLabelElementDerived; use dom::bindings::codegen::InheritTypes::HTMLLabelElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLLabelElementTypeId; use dom::element::HTMLLabelElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLLabelElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLLabelElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLLabelElement> {
let element = HTMLLabelElement::new_inherited(localName, document.clone()); let element = HTMLLabelElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLLabelElementBinding::Wrap) Node::reflect_node(~element, document, HTMLLabelElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmllegendelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLLegendElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLLegendElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLLegendElementDerived; use dom::bindings::codegen::InheritTypes::HTMLLegendElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLLegendElementTypeId; use dom::element::HTMLLegendElementTypeId;
@ -34,8 +34,8 @@ impl HTMLLegendElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLLegendElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLLegendElement> {
let element = HTMLLegendElement::new_inherited(localName, document.clone()); let element = HTMLLegendElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLLegendElementBinding::Wrap) Node::reflect_node(~element, document, HTMLLegendElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmllielement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLLIElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLLIElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLLIElementDerived; use dom::bindings::codegen::InheritTypes::HTMLLIElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLLIElementTypeId; use dom::element::HTMLLIElementTypeId;
@ -34,8 +34,8 @@ impl HTMLLIElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLLIElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLLIElement> {
let element = HTMLLIElement::new_inherited(localName, document.clone()); let element = HTMLLIElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLLIElementBinding::Wrap) Node::reflect_node(~element, document, HTMLLIElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmllinkelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLLinkElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLLinkElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLLinkElementDerived; use dom::bindings::codegen::InheritTypes::HTMLLinkElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLLinkElementTypeId; use dom::element::HTMLLinkElementTypeId;
@ -34,8 +34,8 @@ impl HTMLLinkElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLLinkElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLLinkElement> {
let element = HTMLLinkElement::new_inherited(localName, document.clone()); let element = HTMLLinkElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLLinkElementBinding::Wrap) Node::reflect_node(~element, document, HTMLLinkElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlmainelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLMainElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLMainElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLMainElementDerived; use dom::bindings::codegen::InheritTypes::HTMLMainElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLMainElementTypeId; use dom::element::HTMLMainElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLMainElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLMainElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLMainElement> {
let element = HTMLMainElement::new_inherited(localName, document.clone()); let element = HTMLMainElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLMainElementBinding::Wrap) Node::reflect_node(~element, document, HTMLMainElementBinding::Wrap)
} }
} }

10
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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;
@ -35,8 +35,8 @@ impl HTMLMapElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLMapElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLMapElement> {
let element = HTMLMapElement::new_inherited(localName, document.clone()); let element = HTMLMapElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLMapElementBinding::Wrap) Node::reflect_node(~element, document, HTMLMapElementBinding::Wrap)
} }
} }
@ -51,9 +51,11 @@ impl HTMLMapElement {
} }
pub fn Areas(&self) -> JS<HTMLCollection> { pub fn Areas(&self) -> JS<HTMLCollection> {
let roots = RootCollection::new();
// FIXME: https://github.com/mozilla/servo/issues/1845 // FIXME: https://github.com/mozilla/servo/issues/1845
let doc = self.htmlelement.element.node.owner_doc(); let doc = self.htmlelement.element.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
HTMLCollection::new(&doc.window, Static(vec!())) let window = doc.window.root(&roots);
HTMLCollection::new(&window.root_ref(), Static(vec!()))
} }
} }

6
src/components/script/dom/htmlmetaelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLMetaElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLMetaElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLMetaElementDerived; use dom::bindings::codegen::InheritTypes::HTMLMetaElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLMetaElementTypeId; use dom::element::HTMLMetaElementTypeId;
@ -34,8 +34,8 @@ impl HTMLMetaElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLMetaElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLMetaElement> {
let element = HTMLMetaElement::new_inherited(localName, document.clone()); let element = HTMLMetaElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLMetaElementBinding::Wrap) Node::reflect_node(~element, document, HTMLMetaElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlmeterelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLMeterElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLMeterElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLMeterElementDerived; use dom::bindings::codegen::InheritTypes::HTMLMeterElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLMeterElementTypeId; use dom::element::HTMLMeterElementTypeId;
@ -34,8 +34,8 @@ impl HTMLMeterElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLMeterElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLMeterElement> {
let element = HTMLMeterElement::new_inherited(localName, document.clone()); let element = HTMLMeterElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLMeterElementBinding::Wrap) Node::reflect_node(~element, document, HTMLMeterElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlmodelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLModElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLModElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLModElementDerived; use dom::bindings::codegen::InheritTypes::HTMLModElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLModElementTypeId; use dom::element::HTMLModElementTypeId;
@ -34,8 +34,8 @@ impl HTMLModElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLModElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLModElement> {
let element = HTMLModElement::new_inherited(localName, document.clone()); let element = HTMLModElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLModElementBinding::Wrap) Node::reflect_node(~element, document, HTMLModElementBinding::Wrap)
} }
} }

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

@ -5,7 +5,7 @@
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -47,8 +47,8 @@ impl HTMLObjectElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLObjectElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLObjectElement> {
let element = HTMLObjectElement::new_inherited(localName, document.clone()); let element = HTMLObjectElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLObjectElementBinding::Wrap) Node::reflect_node(~element, document, HTMLObjectElementBinding::Wrap)
} }
} }
@ -144,9 +144,11 @@ impl HTMLObjectElement {
} }
pub fn Validity(&self) -> JS<ValidityState> { pub fn Validity(&self) -> JS<ValidityState> {
let roots = RootCollection::new();
let doc = self.htmlelement.element.node.owner_doc(); let doc = self.htmlelement.element.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
ValidityState::new(&doc.window) let window = doc.window.root(&roots);
ValidityState::new(&window.root_ref())
} }
pub fn ValidationMessage(&self) -> DOMString { pub fn ValidationMessage(&self) -> DOMString {

6
src/components/script/dom/htmlolistelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLOListElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLOListElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLOListElementDerived; use dom::bindings::codegen::InheritTypes::HTMLOListElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLOListElementTypeId; use dom::element::HTMLOListElementTypeId;
@ -34,8 +34,8 @@ impl HTMLOListElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLOListElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLOListElement> {
let element = HTMLOListElement::new_inherited(localName, document.clone()); let element = HTMLOListElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLOListElementBinding::Wrap) Node::reflect_node(~element, document, HTMLOListElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmloptgroupelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLOptGroupElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLOptGroupElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLOptGroupElementDerived; use dom::bindings::codegen::InheritTypes::HTMLOptGroupElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLOptGroupElementTypeId; use dom::element::HTMLOptGroupElementTypeId;
@ -34,8 +34,8 @@ impl HTMLOptGroupElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLOptGroupElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLOptGroupElement> {
let element = HTMLOptGroupElement::new_inherited(localName, document.clone()); let element = HTMLOptGroupElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLOptGroupElementBinding::Wrap) Node::reflect_node(~element, document, HTMLOptGroupElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmloptionelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLOptionElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLOptionElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLOptionElementDerived; use dom::bindings::codegen::InheritTypes::HTMLOptionElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLOptionElementTypeId; use dom::element::HTMLOptionElementTypeId;
@ -35,8 +35,8 @@ impl HTMLOptionElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLOptionElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLOptionElement> {
let element = HTMLOptionElement::new_inherited(localName, document.clone()); let element = HTMLOptionElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLOptionElementBinding::Wrap) Node::reflect_node(~element, document, HTMLOptionElementBinding::Wrap)
} }
} }

10
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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;
@ -36,8 +36,8 @@ impl HTMLOutputElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLOutputElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLOutputElement> {
let element = HTMLOutputElement::new_inherited(localName, document.clone()); let element = HTMLOutputElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLOutputElementBinding::Wrap) Node::reflect_node(~element, document, HTMLOutputElementBinding::Wrap)
} }
} }
@ -83,9 +83,11 @@ impl HTMLOutputElement {
} }
pub fn Validity(&self) -> JS<ValidityState> { pub fn Validity(&self) -> JS<ValidityState> {
let roots = RootCollection::new();
let doc = self.htmlelement.element.node.owner_doc(); let doc = self.htmlelement.element.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
ValidityState::new(&doc.window) let window = doc.window.root(&roots);
ValidityState::new(&window.root_ref())
} }
pub fn SetValidity(&mut self, _validity: JS<ValidityState>) { pub fn SetValidity(&mut self, _validity: JS<ValidityState>) {

6
src/components/script/dom/htmlparagraphelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLParagraphElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLParagraphElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLParagraphElementDerived; use dom::bindings::codegen::InheritTypes::HTMLParagraphElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLParagraphElementTypeId; use dom::element::HTMLParagraphElementTypeId;
@ -34,8 +34,8 @@ impl HTMLParagraphElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLParagraphElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLParagraphElement> {
let element = HTMLParagraphElement::new_inherited(localName, document.clone()); let element = HTMLParagraphElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLParagraphElementBinding::Wrap) Node::reflect_node(~element, document, HTMLParagraphElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlparamelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLParamElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLParamElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLParamElementDerived; use dom::bindings::codegen::InheritTypes::HTMLParamElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLParamElementTypeId; use dom::element::HTMLParamElementTypeId;
@ -34,8 +34,8 @@ impl HTMLParamElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLParamElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLParamElement> {
let element = HTMLParamElement::new_inherited(localName, document.clone()); let element = HTMLParamElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLParamElementBinding::Wrap) Node::reflect_node(~element, document, HTMLParamElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlpreelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLPreElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLPreElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLPreElementDerived; use dom::bindings::codegen::InheritTypes::HTMLPreElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLPreElementTypeId; use dom::element::HTMLPreElementTypeId;
@ -34,8 +34,8 @@ impl HTMLPreElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLPreElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLPreElement> {
let element = HTMLPreElement::new_inherited(localName, document.clone()); let element = HTMLPreElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLPreElementBinding::Wrap) Node::reflect_node(~element, document, HTMLPreElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlprogresselement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLProgressElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLProgressElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLProgressElementDerived; use dom::bindings::codegen::InheritTypes::HTMLProgressElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::{ErrorResult, Fallible}; use dom::bindings::error::{ErrorResult, Fallible};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLProgressElementTypeId; use dom::element::HTMLProgressElementTypeId;
@ -34,8 +34,8 @@ impl HTMLProgressElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLProgressElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLProgressElement> {
let element = HTMLProgressElement::new_inherited(localName, document.clone()); let element = HTMLProgressElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLProgressElementBinding::Wrap) Node::reflect_node(~element, document, HTMLProgressElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlquoteelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLQuoteElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLQuoteElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLQuoteElementDerived; use dom::bindings::codegen::InheritTypes::HTMLQuoteElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLQuoteElementTypeId; use dom::element::HTMLQuoteElementTypeId;
@ -34,8 +34,8 @@ impl HTMLQuoteElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLQuoteElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLQuoteElement> {
let element = HTMLQuoteElement::new_inherited(localName, document.clone()); let element = HTMLQuoteElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLQuoteElementBinding::Wrap) Node::reflect_node(~element, document, HTMLQuoteElementBinding::Wrap)
} }
} }

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLScriptElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLScriptElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLScriptElementDerived; use dom::bindings::codegen::InheritTypes::HTMLScriptElementDerived;
use dom::bindings::codegen::InheritTypes::ElementCast; use dom::bindings::codegen::InheritTypes::ElementCast;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::{HTMLScriptElementTypeId, Element, AttributeHandlers}; use dom::element::{HTMLScriptElementTypeId, Element, AttributeHandlers};
@ -35,19 +35,19 @@ impl HTMLScriptElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLScriptElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLScriptElement> {
let element = HTMLScriptElement::new_inherited(localName, document.clone()); let element = HTMLScriptElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLScriptElementBinding::Wrap) Node::reflect_node(~element, document, HTMLScriptElementBinding::Wrap)
} }
} }
impl HTMLScriptElement { impl HTMLScriptElement {
pub fn Src(&self, abstract_self: &JS<HTMLScriptElement>) -> DOMString { pub fn Src(&self, abstract_self: &JSRef<HTMLScriptElement>) -> DOMString {
let element: JS<Element> = ElementCast::from(abstract_self); let element: JS<Element> = ElementCast::from(&abstract_self.unrooted());
element.get_url_attribute("src") element.get_url_attribute("src")
} }
pub fn SetSrc(&mut self, _abstract_self: &JS<HTMLScriptElement>, _src: DOMString) -> ErrorResult { pub fn SetSrc(&mut self, _abstract_self: &JSRef<HTMLScriptElement>, _src: DOMString) -> ErrorResult {
Ok(()) Ok(())
} }

12
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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};
@ -38,8 +38,8 @@ impl HTMLSelectElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLSelectElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLSelectElement> {
let element = HTMLSelectElement::new_inherited(localName, document.clone()); let element = HTMLSelectElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLSelectElementBinding::Wrap) Node::reflect_node(~element, document, HTMLSelectElementBinding::Wrap)
} }
} }
@ -121,7 +121,7 @@ impl HTMLSelectElement {
None None
} }
pub fn IndexedSetter(&mut self, _index: u32, _option: Option<JS<HTMLOptionElement>>) -> ErrorResult { pub fn IndexedSetter(&mut self, _index: u32, _option: Option<JSRef<HTMLOptionElement>>) -> ErrorResult {
Ok(()) Ok(())
} }
@ -154,9 +154,11 @@ impl HTMLSelectElement {
} }
pub fn Validity(&self) -> JS<ValidityState> { pub fn Validity(&self) -> JS<ValidityState> {
let roots = RootCollection::new();
let doc = self.htmlelement.element.node.owner_doc(); let doc = self.htmlelement.element.node.owner_doc();
let doc = doc.get(); let doc = doc.get();
ValidityState::new(&doc.window) let window = doc.window.root(&roots);
ValidityState::new(&window.root_ref())
} }
pub fn SetValidity(&mut self, _validity: JS<ValidityState>) { pub fn SetValidity(&mut self, _validity: JS<ValidityState>) {

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

@ -7,7 +7,7 @@ use dom::attr::Attr;
use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, CommentCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, CommentCast};
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::JS; use dom::bindings::js::{JS, JSRef, RootCollection};
use dom::characterdata::CharacterData; use dom::characterdata::CharacterData;
use dom::comment::Comment; use dom::comment::Comment;
use dom::documenttype::DocumentType; use dom::documenttype::DocumentType;
@ -20,6 +20,7 @@ use dom::processinginstruction::ProcessingInstruction;
use dom::text::Text; use dom::text::Text;
pub fn serialize(iterator: &mut NodeIterator) -> ~str { pub fn serialize(iterator: &mut NodeIterator) -> ~str {
let roots = RootCollection::new();
let mut html = ~""; let mut html = ~"";
let mut open_elements: Vec<~str> = vec!(); let mut open_elements: Vec<~str> = vec!();
@ -31,23 +32,28 @@ pub fn serialize(iterator: &mut NodeIterator) -> ~str {
match node.type_id() { match node.type_id() {
ElementNodeTypeId(..) => { ElementNodeTypeId(..) => {
let elem: JS<Element> = ElementCast::to(&node).unwrap(); let elem: JS<Element> = ElementCast::to(&node).unwrap();
serialize_elem(&elem, &mut open_elements) let elem = elem.root(&roots);
serialize_elem(&elem.root_ref(), &mut open_elements)
} }
CommentNodeTypeId => { CommentNodeTypeId => {
let comment: JS<Comment> = CommentCast::to(&node).unwrap(); let comment: JS<Comment> = CommentCast::to(&node).unwrap();
serialize_comment(&comment) let comment = comment.root(&roots);
serialize_comment(&comment.root_ref())
} }
TextNodeTypeId => { TextNodeTypeId => {
let text: JS<Text> = TextCast::to(&node).unwrap(); let text: JS<Text> = TextCast::to(&node).unwrap();
serialize_text(&text) let text = text.root(&roots);
serialize_text(&text.root_ref())
} }
DoctypeNodeTypeId => { DoctypeNodeTypeId => {
let doctype: JS<DocumentType> = DocumentTypeCast::to(&node).unwrap(); let doctype: JS<DocumentType> = DocumentTypeCast::to(&node).unwrap();
serialize_doctype(&doctype) let doctype = doctype.root(&roots);
serialize_doctype(&doctype.root_ref())
} }
ProcessingInstructionNodeTypeId => { ProcessingInstructionNodeTypeId => {
let processing_instruction: JS<ProcessingInstruction> = ProcessingInstructionCast::to(&node).unwrap(); let processing_instruction: JS<ProcessingInstruction> = ProcessingInstructionCast::to(&node).unwrap();
serialize_processing_instruction(&processing_instruction) let processing_instruction = processing_instruction.root(&roots);
serialize_processing_instruction(&processing_instruction.root_ref())
} }
DocumentFragmentNodeTypeId => { DocumentFragmentNodeTypeId => {
~"" ~""
@ -64,11 +70,11 @@ pub fn serialize(iterator: &mut NodeIterator) -> ~str {
html html
} }
fn serialize_comment(comment: &JS<Comment>) -> ~str { fn serialize_comment(comment: &JSRef<Comment>) -> ~str {
~"<!--" + comment.get().characterdata.data + "-->" ~"<!--" + comment.get().characterdata.data + "-->"
} }
fn serialize_text(text: &JS<Text>) -> ~str { fn serialize_text(text: &JSRef<Text>) -> ~str {
match text.get().characterdata.node.parent_node { match text.get().characterdata.node.parent_node {
Some(ref parent) if parent.is_element() => { Some(ref parent) if parent.is_element() => {
let elem: JS<Element> = ElementCast::to(parent).unwrap(); let elem: JS<Element> = ElementCast::to(parent).unwrap();
@ -85,18 +91,20 @@ fn serialize_text(text: &JS<Text>) -> ~str {
} }
} }
fn serialize_processing_instruction(processing_instruction: &JS<ProcessingInstruction>) -> ~str { fn serialize_processing_instruction(processing_instruction: &JSRef<ProcessingInstruction>) -> ~str {
~"<?" + processing_instruction.get().target + " " + processing_instruction.get().characterdata.data + "?>" ~"<?" + processing_instruction.get().target + " " + processing_instruction.get().characterdata.data + "?>"
} }
fn serialize_doctype(doctype: &JS<DocumentType>) -> ~str { fn serialize_doctype(doctype: &JSRef<DocumentType>) -> ~str {
~"<!DOCTYPE" + doctype.get().name + ">" ~"<!DOCTYPE" + doctype.get().name + ">"
} }
fn serialize_elem(elem: &JS<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() {
rv.push_str(serialize_attr(attr)); let attr = attr.root(&roots);
rv.push_str(serialize_attr(&attr.root_ref()));
}; };
rv.push_str(">"); rv.push_str(">");
match elem.get().local_name.as_slice() { match elem.get().local_name.as_slice() {
@ -119,7 +127,7 @@ fn serialize_elem(elem: &JS<Element>, open_elements: &mut Vec<~str>) -> ~str {
rv rv
} }
fn serialize_attr(attr: &JS<Attr>) -> ~str { fn serialize_attr(attr: &JSRef<Attr>) -> ~str {
let attr_name = if attr.get().namespace == namespace::XML { let attr_name = if attr.get().namespace == namespace::XML {
~"xml:" + attr.get().local_name.clone() ~"xml:" + attr.get().local_name.clone()
} else if attr.get().namespace == namespace::XMLNS && } else if attr.get().namespace == namespace::XMLNS &&

6
src/components/script/dom/htmlsourceelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLSourceElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLSourceElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLSourceElementDerived; use dom::bindings::codegen::InheritTypes::HTMLSourceElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLSourceElementTypeId; use dom::element::HTMLSourceElementTypeId;
@ -34,8 +34,8 @@ impl HTMLSourceElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLSourceElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLSourceElement> {
let element = HTMLSourceElement::new_inherited(localName, document.clone()); let element = HTMLSourceElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLSourceElementBinding::Wrap) Node::reflect_node(~element, document, HTMLSourceElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlspanelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLSpanElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLSpanElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLSpanElementDerived; use dom::bindings::codegen::InheritTypes::HTMLSpanElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLSpanElementTypeId; use dom::element::HTMLSpanElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLSpanElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLSpanElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLSpanElement> {
let element = HTMLSpanElement::new_inherited(localName, document.clone()); let element = HTMLSpanElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLSpanElementBinding::Wrap) Node::reflect_node(~element, document, HTMLSpanElementBinding::Wrap)
} }
} }

10
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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;
@ -37,8 +37,8 @@ impl HTMLStyleElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLStyleElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLStyleElement> {
let element = HTMLStyleElement::new_inherited(localName, document.clone()); let element = HTMLStyleElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLStyleElementBinding::Wrap) Node::reflect_node(~element, document, HTMLStyleElementBinding::Wrap)
} }
} }
@ -82,11 +82,13 @@ pub trait StyleElementHelpers {
impl StyleElementHelpers for JS<HTMLStyleElement> { impl StyleElementHelpers for JS<HTMLStyleElement> {
fn parse_own_css(&self) { fn parse_own_css(&self) {
let roots = RootCollection::new();
let node: JS<Node> = NodeCast::from(self); let node: JS<Node> = NodeCast::from(self);
let node_root = node.root(&roots);
let win = window_from_node(&node); let win = window_from_node(&node);
let url = win.get().page().get_url(); let url = win.get().page().get_url();
let data = node.get().GetTextContent(&node).expect("Element.textContent must be a string"); let data = node.get().GetTextContent(&node_root.root_ref()).expect("Element.textContent must be a string");
let sheet = parse_inline_css(url, data); let sheet = parse_inline_css(url, data);
let LayoutChan(ref layout_chan) = *win.get().page().layout_chan; let LayoutChan(ref layout_chan) = *win.get().page().layout_chan;
layout_chan.send(AddStylesheetMsg(sheet)); layout_chan.send(AddStylesheetMsg(sheet));

6
src/components/script/dom/htmltablecaptionelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTableCaptionElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTableCaptionElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTableCaptionElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTableCaptionElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTableCaptionElementTypeId; use dom::element::HTMLTableCaptionElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTableCaptionElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTableCaptionElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTableCaptionElement> {
let element = HTMLTableCaptionElement::new_inherited(localName, document.clone()); let element = HTMLTableCaptionElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTableCaptionElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTableCaptionElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltablecolelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTableColElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTableColElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTableColElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTableColElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTableColElementTypeId; use dom::element::HTMLTableColElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTableColElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTableColElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTableColElement> {
let element = HTMLTableColElement::new_inherited(localName, document.clone()); let element = HTMLTableColElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTableColElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTableColElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltabledatacellelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTableDataCellElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTableDataCellElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTableDataCellElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTableDataCellElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTableDataCellElementTypeId; use dom::element::HTMLTableDataCellElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLTableDataCellElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTableDataCellElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTableDataCellElement> {
let element = HTMLTableDataCellElement::new_inherited(localName, document.clone()); let element = HTMLTableDataCellElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTableDataCellElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTableDataCellElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltableelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTableElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTableElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTableElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTableElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTableElementTypeId; use dom::element::HTMLTableElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTableElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTableElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTableElement> {
let element = HTMLTableElement::new_inherited(localName, document.clone()); let element = HTMLTableElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTableElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTableElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltableheadercellelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTableHeaderCellElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTableHeaderCellElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTableHeaderCellElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTableHeaderCellElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTableHeaderCellElementTypeId; use dom::element::HTMLTableHeaderCellElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLTableHeaderCellElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTableHeaderCellElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTableHeaderCellElement> {
let element = HTMLTableHeaderCellElement::new_inherited(localName, document.clone()); let element = HTMLTableHeaderCellElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTableHeaderCellElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTableHeaderCellElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltablerowelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTableRowElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTableRowElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTableRowElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTableRowElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTableRowElementTypeId; use dom::element::HTMLTableRowElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTableRowElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTableRowElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTableRowElement> {
let element = HTMLTableRowElement::new_inherited(localName, document.clone()); let element = HTMLTableRowElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTableRowElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTableRowElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltablesectionelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTableSectionElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTableSectionElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTableSectionElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTableSectionElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTableSectionElementTypeId; use dom::element::HTMLTableSectionElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTableSectionElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTableSectionElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTableSectionElement> {
let element = HTMLTableSectionElement::new_inherited(localName, document.clone()); let element = HTMLTableSectionElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTableSectionElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTableSectionElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltemplateelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTemplateElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTemplateElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTemplateElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTemplateElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTemplateElementTypeId; use dom::element::HTMLTemplateElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLTemplateElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTemplateElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTemplateElement> {
let element = HTMLTemplateElement::new_inherited(localName, document.clone()); let element = HTMLTemplateElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTemplateElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTemplateElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltextareaelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTextAreaElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTextAreaElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTextAreaElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTextAreaElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::{ErrorResult, Fallible}; use dom::bindings::error::{ErrorResult, Fallible};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTextAreaElementTypeId; use dom::element::HTMLTextAreaElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTextAreaElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTextAreaElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTextAreaElement> {
let element = HTMLTextAreaElement::new_inherited(localName, document.clone()); let element = HTMLTextAreaElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTextAreaElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTextAreaElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltimeelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTimeElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTimeElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTimeElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTimeElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTimeElementTypeId; use dom::element::HTMLTimeElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTimeElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTimeElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTimeElement> {
let element = HTMLTimeElement::new_inherited(localName, document.clone()); let element = HTMLTimeElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTimeElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTimeElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltitleelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTitleElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTitleElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTitleElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTitleElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTitleElementTypeId; use dom::element::HTMLTitleElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTitleElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTitleElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTitleElement> {
let element = HTMLTitleElement::new_inherited(localName, document.clone()); let element = HTMLTitleElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTitleElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTitleElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmltrackelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLTrackElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLTrackElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLTrackElementDerived; use dom::bindings::codegen::InheritTypes::HTMLTrackElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLTrackElementTypeId; use dom::element::HTMLTrackElementTypeId;
@ -34,8 +34,8 @@ impl HTMLTrackElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLTrackElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLTrackElement> {
let element = HTMLTrackElement::new_inherited(localName, document.clone()); let element = HTMLTrackElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLTrackElementBinding::Wrap) Node::reflect_node(~element, document, HTMLTrackElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlulistelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLUListElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLUListElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLUListElementDerived; use dom::bindings::codegen::InheritTypes::HTMLUListElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLUListElementTypeId; use dom::element::HTMLUListElementTypeId;
@ -34,8 +34,8 @@ impl HTMLUListElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLUListElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLUListElement> {
let element = HTMLUListElement::new_inherited(localName, document.clone()); let element = HTMLUListElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLUListElementBinding::Wrap) Node::reflect_node(~element, document, HTMLUListElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlunknownelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLUnknownElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLUnknownElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLUnknownElementDerived; use dom::bindings::codegen::InheritTypes::HTMLUnknownElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLUnknownElementTypeId; use dom::element::HTMLUnknownElementTypeId;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -33,8 +33,8 @@ impl HTMLUnknownElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLUnknownElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLUnknownElement> {
let element = HTMLUnknownElement::new_inherited(localName, document.clone()); let element = HTMLUnknownElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLUnknownElementBinding::Wrap) Node::reflect_node(~element, document, HTMLUnknownElementBinding::Wrap)
} }
} }

6
src/components/script/dom/htmlvideoelement.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::HTMLVideoElementBinding; use dom::bindings::codegen::BindingDeclarations::HTMLVideoElementBinding;
use dom::bindings::codegen::InheritTypes::HTMLVideoElementDerived; use dom::bindings::codegen::InheritTypes::HTMLVideoElementDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::document::Document; use dom::document::Document;
use dom::element::HTMLVideoElementTypeId; use dom::element::HTMLVideoElementTypeId;
@ -34,8 +34,8 @@ impl HTMLVideoElement {
} }
} }
pub fn new(localName: DOMString, document: &JS<Document>) -> JS<HTMLVideoElement> { pub fn new(localName: DOMString, document: &JSRef<Document>) -> JS<HTMLVideoElement> {
let element = HTMLVideoElement::new_inherited(localName, document.clone()); let element = HTMLVideoElement::new_inherited(localName, document.unrooted());
Node::reflect_node(~element, document, HTMLVideoElementBinding::Wrap) Node::reflect_node(~element, document, HTMLVideoElementBinding::Wrap)
} }
} }

4
src/components/script/dom/location.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::LocationBinding; use dom::bindings::codegen::BindingDeclarations::LocationBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
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::window::Window; use dom::window::Window;
@ -29,7 +29,7 @@ impl Location {
} }
} }
pub fn new(window: &JS<Window>, page: Rc<Page>) -> JS<Location> { pub fn new(window: &JSRef<Window>, page: Rc<Page>) -> JS<Location> {
reflect_dom_object(~Location::new_inherited(page), reflect_dom_object(~Location::new_inherited(page),
window, window,
LocationBinding::Wrap) LocationBinding::Wrap)

19
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::MouseEventDerived; use dom::bindings::codegen::InheritTypes::MouseEventDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef, RootCollection, RootedReference};
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};
@ -51,21 +51,24 @@ impl MouseEvent {
} }
} }
pub fn new(window: &JS<Window>) -> JS<MouseEvent> { pub fn new(window: &JSRef<Window>) -> JS<MouseEvent> {
reflect_dom_object(~MouseEvent::new_inherited(), reflect_dom_object(~MouseEvent::new_inherited(),
window, window,
MouseEventBinding::Wrap) MouseEventBinding::Wrap)
} }
pub fn Constructor(owner: &JS<Window>, pub fn Constructor(owner: &JSRef<Window>,
type_: DOMString, type_: DOMString,
init: &MouseEventBinding::MouseEventInit) -> Fallible<JS<MouseEvent>> { init: &MouseEventBinding::MouseEventInit) -> Fallible<JS<MouseEvent>> {
let roots = RootCollection::new();
let mut ev = MouseEvent::new(owner); let mut ev = MouseEvent::new(owner);
ev.get_mut().InitMouseEvent(type_, init.bubbles, init.cancelable, init.view.clone(), let view = init.view.as_ref().map(|view| view.root(&roots));
let related_target = init.relatedTarget.as_ref().map(|relatedTarget| relatedTarget.root(&roots));
ev.get_mut().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,
init.altKey, init.shiftKey, init.metaKey, init.altKey, init.shiftKey, init.metaKey,
init.button, init.relatedTarget.clone()); init.button, related_target.root_ref());
Ok(ev) Ok(ev)
} }
@ -123,7 +126,7 @@ impl MouseEvent {
typeArg: DOMString, typeArg: DOMString,
canBubbleArg: bool, canBubbleArg: bool,
cancelableArg: bool, cancelableArg: bool,
viewArg: Option<JS<Window>>, viewArg: Option<JSRef<Window>>,
detailArg: i32, detailArg: i32,
screenXArg: i32, screenXArg: i32,
screenYArg: i32, screenYArg: i32,
@ -134,7 +137,7 @@ impl MouseEvent {
shiftKeyArg: bool, shiftKeyArg: bool,
metaKeyArg: bool, metaKeyArg: bool,
buttonArg: u16, buttonArg: u16,
relatedTargetArg: Option<JS<EventTarget>>) { relatedTargetArg: Option<JSRef<EventTarget>>) {
self.mouseevent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg); self.mouseevent.InitUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
self.screen_x = screenXArg; self.screen_x = screenXArg;
self.screen_y = screenYArg; self.screen_y = screenYArg;
@ -145,7 +148,7 @@ impl MouseEvent {
self.shift_key = shiftKeyArg; self.shift_key = shiftKeyArg;
self.meta_key = metaKeyArg; self.meta_key = metaKeyArg;
self.button = buttonArg; self.button = buttonArg;
self.related_target = relatedTargetArg; self.related_target = relatedTargetArg.map(|target| target.unrooted());
} }
} }

4
src/components/script/dom/navigator.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::NavigatorBinding; use dom::bindings::codegen::BindingDeclarations::NavigatorBinding;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
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::window::Window; use dom::window::Window;
@ -21,7 +21,7 @@ impl Navigator {
} }
} }
pub fn new(window: &JS<Window>) -> JS<Navigator> { pub fn new(window: &JSRef<Window>) -> JS<Navigator> {
reflect_dom_object(~Navigator::new_inherited(), reflect_dom_object(~Navigator::new_inherited(),
window, window,
NavigatorBinding::Wrap) NavigatorBinding::Wrap)

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

File diff suppressed because it is too large Load diff

12
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; use dom::bindings::js::{JS, JSRef};
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;
@ -31,18 +31,18 @@ impl NodeList {
} }
} }
pub fn new(window: &JS<Window>, pub fn new(window: &JSRef<Window>,
list_type: NodeListType) -> JS<NodeList> { list_type: NodeListType) -> JS<NodeList> {
reflect_dom_object(~NodeList::new_inherited(window.clone(), list_type), reflect_dom_object(~NodeList::new_inherited(window.unrooted(), list_type),
window, NodeListBinding::Wrap) window, NodeListBinding::Wrap)
} }
pub fn new_simple_list(window: &JS<Window>, elements: Vec<JS<Node>>) -> JS<NodeList> { pub fn new_simple_list(window: &JSRef<Window>, elements: Vec<JS<Node>>) -> JS<NodeList> {
NodeList::new(window, Simple(elements)) NodeList::new(window, Simple(elements))
} }
pub fn new_child_list(window: &JS<Window>, node: &JS<Node>) -> JS<NodeList> { pub fn new_child_list(window: &JSRef<Window>, node: &JSRef<Node>) -> JS<NodeList> {
NodeList::new(window, Children(node.clone())) NodeList::new(window, Children(node.unrooted()))
} }
pub fn Length(&self) -> u32 { pub fn Length(&self) -> u32 {

6
src/components/script/dom/processinginstruction.rs
View file

@ -4,7 +4,7 @@
use dom::bindings::codegen::BindingDeclarations::ProcessingInstructionBinding; use dom::bindings::codegen::BindingDeclarations::ProcessingInstructionBinding;
use dom::bindings::codegen::InheritTypes::ProcessingInstructionDerived; use dom::bindings::codegen::InheritTypes::ProcessingInstructionDerived;
use dom::bindings::js::JS; use dom::bindings::js::{JS, JSRef};
use dom::characterdata::CharacterData; use dom::characterdata::CharacterData;
use dom::document::Document; use dom::document::Document;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
@ -35,8 +35,8 @@ impl ProcessingInstruction {
} }
} }
pub fn new(target: DOMString, data: DOMString, document: &JS<Document>) -> JS<ProcessingInstruction> { pub fn new(target: DOMString, data: DOMString, document: &JSRef<Document>) -> JS<ProcessingInstruction> {
let node = ProcessingInstruction::new_inherited(target, data, document.clone()); let node = ProcessingInstruction::new_inherited(target, data, document.unrooted());
Node::reflect_node(~node, document, ProcessingInstructionBinding::Wrap) Node::reflect_node(~node, document, ProcessingInstructionBinding::Wrap)
} }
} }

26
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; use dom::bindings::js::{JS, JSRef, RootCollection};
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;
@ -51,8 +51,12 @@ impl TestBinding {
pub fn SetByteStringAttribute(&self, _: ByteString) {} pub fn SetByteStringAttribute(&self, _: ByteString) {}
pub fn EnumAttribute(&self) -> TestEnum { _empty } pub fn EnumAttribute(&self) -> TestEnum { _empty }
pub fn SetEnumAttribute(&self, _: TestEnum) {} pub fn SetEnumAttribute(&self, _: TestEnum) {}
pub fn InterfaceAttribute(&self) -> JS<Blob> { Blob::new(&self.window) } pub fn InterfaceAttribute(&self) -> JS<Blob> {
pub fn SetInterfaceAttribute(&self, _: &JS<Blob>) {} let roots = RootCollection::new();
let window = self.window.root(&roots);
Blob::new(&window.root_ref())
}
pub fn SetInterfaceAttribute(&self, _: &JSRef<Blob>) {}
pub fn AnyAttribute(&self, _: *JSContext) -> JSVal { NullValue() } pub fn AnyAttribute(&self, _: *JSContext) -> JSVal { NullValue() }
pub fn SetAnyAttribute(&self, _: *JSContext, _: JSVal) {} pub fn SetAnyAttribute(&self, _: *JSContext, _: JSVal) {}
@ -83,8 +87,12 @@ impl TestBinding {
pub fn GetStringAttributeNullable(&self) -> Option<DOMString> { Some(~"") } pub fn GetStringAttributeNullable(&self) -> Option<DOMString> { Some(~"") }
pub fn SetStringAttributeNullable(&self, _: Option<DOMString>) {} pub fn SetStringAttributeNullable(&self, _: Option<DOMString>) {}
pub fn GetEnumAttributeNullable(&self) -> Option<TestEnum> { Some(_empty) } pub fn GetEnumAttributeNullable(&self) -> Option<TestEnum> { Some(_empty) }
pub fn GetInterfaceAttributeNullable(&self) -> Option<JS<Blob>> { Some(Blob::new(&self.window)) } pub fn GetInterfaceAttributeNullable(&self) -> Option<JS<Blob>> {
pub fn SetInterfaceAttributeNullable(&self, _: Option<JS<Blob>>) {} let roots = RootCollection::new();
let window = self.window.root(&roots);
Some(Blob::new(&window.root_ref()))
}
pub fn SetInterfaceAttributeNullable(&self, _: Option<JSRef<Blob>>) {}
pub fn PassBoolean(&self, _: bool) {} pub fn PassBoolean(&self, _: bool) {}
pub fn PassByte(&self, _: i8) {} pub fn PassByte(&self, _: i8) {}
@ -100,7 +108,7 @@ impl TestBinding {
pub fn PassString(&self, _: DOMString) {} pub fn PassString(&self, _: DOMString) {}
pub fn PassByteString(&self, _: ByteString) {} pub fn PassByteString(&self, _: ByteString) {}
pub fn PassEnum(&self, _: TestEnum) {} pub fn PassEnum(&self, _: TestEnum) {}
pub fn PassInterface(&self, _: &JS<Blob>) {} pub fn PassInterface(&self, _: &JSRef<Blob>) {}
pub fn PassUnion(&self, _: HTMLElementOrLong) {} pub fn PassUnion(&self, _: HTMLElementOrLong) {}
pub fn PassAny(&self, _: *JSContext, _: JSVal) {} pub fn PassAny(&self, _: *JSContext, _: JSVal) {}
@ -118,7 +126,7 @@ impl TestBinding {
pub fn PassNullableString(&self, _: Option<DOMString>) {} pub fn PassNullableString(&self, _: Option<DOMString>) {}
pub fn PassNullableByteString(&self, _: Option<ByteString>) {} pub fn PassNullableByteString(&self, _: Option<ByteString>) {}
// pub fn PassNullableEnum(&self, _: Option<TestEnum>) {} // pub fn PassNullableEnum(&self, _: Option<TestEnum>) {}
pub fn PassNullableInterface(&self, _: Option<JS<Blob>>) {} pub fn PassNullableInterface(&self, _: Option<JSRef<Blob>>) {}
pub fn PassNullableUnion(&self, _: Option<HTMLElementOrLong>) {} pub fn PassNullableUnion(&self, _: Option<HTMLElementOrLong>) {}
pub fn PassNullableAny(&self, _: *JSContext, _: Option<JSVal>) {} pub fn PassNullableAny(&self, _: *JSContext, _: Option<JSVal>) {}
@ -136,7 +144,7 @@ impl TestBinding {
pub fn PassOptionalString(&self, _: Option<DOMString>) {} pub fn PassOptionalString(&self, _: Option<DOMString>) {}
pub fn PassOptionalByteString(&self, _: Option<ByteString>) {} pub fn PassOptionalByteString(&self, _: Option<ByteString>) {}
pub fn PassOptionalEnum(&self, _: Option<TestEnum>) {} pub fn PassOptionalEnum(&self, _: Option<TestEnum>) {}
pub fn PassOptionalInterface(&self, _: Option<JS<Blob>>) {} pub fn PassOptionalInterface(&self, _: Option<JSRef<Blob>>) {}
pub fn PassOptionalUnion(&self, _: Option<HTMLElementOrLong>) {} pub fn PassOptionalUnion(&self, _: Option<HTMLElementOrLong>) {}
pub fn PassOptionalAny(&self, _: *JSContext, _: Option<JSVal>) {} pub fn PassOptionalAny(&self, _: *JSContext, _: Option<JSVal>) {}
@ -183,7 +191,7 @@ impl TestBinding {
pub fn PassOptionalNullableStringWithDefault(&self, _: Option<DOMString>) {} pub fn PassOptionalNullableStringWithDefault(&self, _: Option<DOMString>) {}
pub fn PassOptionalNullableByteStringWithDefault(&self, _: Option<ByteString>) {} pub fn PassOptionalNullableByteStringWithDefault(&self, _: Option<ByteString>) {}
// pub fn PassOptionalNullableEnumWithDefault(&self, _: Option<TestEnum>) {} // pub fn PassOptionalNullableEnumWithDefault(&self, _: Option<TestEnum>) {}
pub fn PassOptionalNullableInterfaceWithDefault(&self, _: Option<JS<Blob>>) {} pub fn PassOptionalNullableInterfaceWithDefault(&self, _: Option<JSRef<Blob>>) {}
pub fn PassOptionalNullableUnionWithDefault(&self, _: Option<HTMLElementOrLong>) {} pub fn PassOptionalNullableUnionWithDefault(&self, _: Option<HTMLElementOrLong>) {}
pub fn PassOptionalAnyWithDefault(&self, _: *JSContext, _: JSVal) {} pub fn PassOptionalAnyWithDefault(&self, _: *JSContext, _: JSVal) {}

Some files were not shown because too many files have changed in this diff Show more