1 files changed, 31 insertions, 16 deletions

diff --git a/src/components/script/dom/nodelist.rs b/src/components/script/dom/nodelist.rs
index 714f0e34079..dc050b995ea 100644
--- a/src/components/script/dom/nodelist.rs
+++ b/src/components/script/dom/nodelist.rs
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::BindingDeclarations::NodeListBinding;
-use dom::bindings::js::JS;
+use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::node::{Node, NodeHelpers};
 use dom::window::Window;
@@ -22,45 +22,60 @@ pub struct NodeList {
 }
 
 impl NodeList {
-    pub fn new_inherited(window: JS<Window>,
+    pub fn new_inherited(window: &JSRef<Window>,
                          list_type: NodeListType) -> NodeList {
         NodeList {
             list_type: list_type,
             reflector_: Reflector::new(),
-            window: window
+            window: window.unrooted()
         }
     }
 
-    pub fn new(window: &JS<Window>,
-               list_type: NodeListType) -> JS<NodeList> {
-        reflect_dom_object(~NodeList::new_inherited(window.clone(), list_type),
+    pub fn new(window: &JSRef<Window>,
+               list_type: NodeListType) -> Temporary<NodeList> {
+        reflect_dom_object(~NodeList::new_inherited(window, list_type),
                            window, NodeListBinding::Wrap)
     }
 
-    pub fn new_simple_list(window: &JS<Window>, elements: Vec<JS<Node>>) -> JS<NodeList> {
-        NodeList::new(window, Simple(elements))
+    pub fn new_simple_list(window: &JSRef<Window>, elements: Vec<JSRef<Node>>) -> Temporary<NodeList> {
+        NodeList::new(window, Simple(elements.iter().map(|element| element.unrooted()).collect()))
     }
 
-    pub fn new_child_list(window: &JS<Window>, node: &JS<Node>) -> JS<NodeList> {
-        NodeList::new(window, Children(node.clone()))
+    pub fn new_child_list(window: &JSRef<Window>, node: &JSRef<Node>) -> Temporary<NodeList> {
+        NodeList::new(window, Children(node.unrooted()))
     }
+}
+
+pub trait NodeListMethods {
+    fn Length(&self) -> u32;
+    fn Item(&self, index: u32) -> Option<Temporary<Node>>;
+    fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<Temporary<Node>>;
+}
 
-    pub fn Length(&self) -> u32 {
+impl<'a> NodeListMethods for JSRef<'a, NodeList> {
+    fn Length(&self) -> u32 {
         match self.list_type {
             Simple(ref elems) => elems.len() as u32,
-            Children(ref node) => node.children().len() as u32
+            Children(ref node) => {
+                let node = node.root();
+                node.deref().children().len() as u32
+            }
         }
     }
 
-    pub fn Item(&self, index: u32) -> Option<JS<Node>> {
+    fn Item(&self, index: u32) -> Option<Temporary<Node>> {
         match self.list_type {
             _ if index >= self.Length() => None,
-            Simple(ref elems) => Some(elems.get(index as uint).clone()),
-            Children(ref node) => node.children().nth(index as uint)
+            Simple(ref elems) => Some(Temporary::new(elems.get(index as uint).clone())),
+            Children(ref node) => {
+                let node = node.root();
+                node.deref().children().nth(index as uint)
+                                       .map(|child| Temporary::from_rooted(&child))
+            }
         }
     }
 
-    pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<JS<Node>> {
+    fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<Temporary<Node>> {
         let item = self.Item(index);
         *found = item.is_some();
         item