Upgrade to SM 39

components/script/dom/treewalker.rs

@@ -10,11 +10,12 @@ use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilter;
 use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilterConstants;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{JS, JSRef, MutHeap, OptionalRootable, Rootable};
-use dom::bindings::js::Temporary;
+use dom::bindings::js::{JS, MutHeap};
+use dom::bindings::js::Root;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::document::{Document, DocumentHelpers};
 use dom::node::Node;
+use std::rc::Rc;
 
 // https://dom.spec.whatwg.org/#interface-treewalker
 #[dom_struct]
@@ -27,32 +28,32 @@ pub struct TreeWalker {
 }
 
 impl TreeWalker {
-    fn new_inherited(root_node: JSRef<Node>,
+    fn new_inherited(root_node: &Node,
                          what_to_show: u32,
                          filter: Filter) -> TreeWalker {
         TreeWalker {
             reflector_: Reflector::new(),
-            root_node: JS::from_rooted(root_node),
-            current_node: MutHeap::new(JS::from_rooted(root_node)),
+            root_node: JS::from_ref(root_node),
+            current_node: MutHeap::new(JS::from_ref(root_node)),
             what_to_show: what_to_show,
             filter: filter
         }
     }
 
-    pub fn new_with_filter(document: JSRef<Document>,
-                           root_node: JSRef<Node>,
+    pub fn new_with_filter(document: &Document,
+                           root_node: &Node,
                            what_to_show: u32,
-                           filter: Filter) -> Temporary<TreeWalker> {
-        let window = document.window().root();
+                           filter: Filter) -> Root<TreeWalker> {
+        let window = document.window();
         reflect_dom_object(box TreeWalker::new_inherited(root_node, what_to_show, filter),
                            GlobalRef::Window(window.r()),
                            TreeWalkerBinding::Wrap)
     }
 
-    pub fn new(document: JSRef<Document>,
-               root_node: JSRef<Node>,
+    pub fn new(document: &Document,
+               root_node: &Node,
                what_to_show: u32,
-               node_filter: Option<NodeFilter>) -> Temporary<TreeWalker> {
+               node_filter: Option<Rc<NodeFilter>>) -> Root<TreeWalker> {
         let filter = match node_filter {
             None => Filter::None,
             Some(jsfilter) => Filter::JS(jsfilter)
@@ -61,10 +62,10 @@ impl TreeWalker {
     }
 }
 
-impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
+impl<'a> TreeWalkerMethods for &'a TreeWalker {
     // https://dom.spec.whatwg.org/#dom-treewalker-root
-    fn Root(self) -> Temporary<Node> {
-        Temporary::from_rooted(self.root_node)
+    fn Root(self) -> Root<Node> {
+        self.root_node.root()
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-whattoshow
@@ -73,40 +74,40 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-filter
-    fn GetFilter(self) -> Option<NodeFilter> {
+    fn GetFilter(self) -> Option<Rc<NodeFilter>> {
         match self.filter {
             Filter::None => None,
-            Filter::JS(nf) => Some(nf),
+            Filter::JS(ref nf) => Some(nf.clone()),
             Filter::Native(_) => panic!("Cannot convert native node filter to DOM NodeFilter")
         }
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-currentnode
-    fn CurrentNode(self) -> Temporary<Node> {
-        Temporary::from_rooted(self.current_node.get())
+    fn CurrentNode(self) -> Root<Node> {
+        self.current_node.get().root()
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-currentnode
-    fn SetCurrentNode(self, node: JSRef<Node>) {
-        self.current_node.set(JS::from_rooted(node));
+    fn SetCurrentNode(self, node: &Node) {
+        self.current_node.set(JS::from_ref(node));
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-parentnode
-    fn ParentNode(self) -> Fallible<Option<Temporary<Node>>> {
+    fn ParentNode(self) -> Fallible<Option<Root<Node>>> {
         // "1. Let node be the value of the currentNode attribute."
-        let mut node = self.current_node.get().root().get_unsound_ref_forever();
+        let mut node = self.current_node.get().root();
         // "2. While node is not null and is not root, run these substeps:"
-        while !self.is_root_node(node) {
+        while !self.is_root_node(node.r()) {
             // "1. Let node be node's parent."
             match node.GetParentNode() {
                 Some(n) => {
-                    node = n.root().get_unsound_ref_forever();
+                    node = n;
                     // "2. If node is not null and filtering node returns FILTER_ACCEPT,
                     //     then set the currentNode attribute to node, return node."
-                    match try!(self.accept_node(node)) {
+                    match try!(self.accept_node(node.r())) {
                         NodeFilterConstants::FILTER_ACCEPT => {
-                            self.current_node.set(JS::from_rooted(node));
-                            return Ok(Some(Temporary::from_rooted(node)))
+                            self.current_node.set(JS::from_rooted(&node));
+                            return Ok(Some(node))
                         },
                         _ => {}
                     }
@@ -119,45 +120,45 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-firstchild
-    fn FirstChild(self) -> Fallible<Option<Temporary<Node>>> {
+    fn FirstChild(self) -> Fallible<Option<Root<Node>>> {
         // "The firstChild() method must traverse children of type first."
         self.traverse_children(|node| node.GetFirstChild(),
                                |node| node.GetNextSibling())
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-lastchild
-    fn LastChild(self) -> Fallible<Option<Temporary<Node>>> {
+    fn LastChild(self) -> Fallible<Option<Root<Node>>> {
         // "The lastChild() method must traverse children of type last."
         self.traverse_children(|node| node.GetLastChild(),
                                |node| node.GetPreviousSibling())
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-previoussibling
-    fn PreviousSibling(self) -> Fallible<Option<Temporary<Node>>> {
+    fn PreviousSibling(self) -> Fallible<Option<Root<Node>>> {
         // "The nextSibling() method must traverse siblings of type next."
         self.traverse_siblings(|node| node.GetLastChild(),
                                |node| node.GetPreviousSibling())
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-nextsibling
-    fn NextSibling(self) -> Fallible<Option<Temporary<Node>>> {
+    fn NextSibling(self) -> Fallible<Option<Root<Node>>> {
         // "The previousSibling() method must traverse siblings of type previous."
         self.traverse_siblings(|node| node.GetFirstChild(),
                                |node| node.GetNextSibling())
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-previousnode
-    fn PreviousNode(self) -> Fallible<Option<Temporary<Node>>> {
+    fn PreviousNode(self) -> Fallible<Option<Root<Node>>> {
         // "1. Let node be the value of the currentNode attribute."
-        let mut node = self.current_node.get().root().get_unsound_ref_forever();
+        let mut node = self.current_node.get().root();
         // "2. While node is not root, run these substeps:"
-        while !self.is_root_node(node) {
+        while !self.is_root_node(node.r()) {
             // "1. Let sibling be the previous sibling of node."
-            let mut sibling_op = node.GetPreviousSibling();
+            let mut sibling_op = node.r().GetPreviousSibling();
             // "2. While sibling is not null, run these subsubsteps:"
             while sibling_op.is_some() {
                 // "1. Set node to sibling."
-                node = sibling_op.unwrap().root().get_unsound_ref_forever();
+                node = sibling_op.unwrap();
                 // "2. Filter node and let result be the return value."
                 // "3. While result is not FILTER_REJECT and node has a child,
                 //     set node to its last child and then filter node and
@@ -165,15 +166,14 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
                 // "4. If result is FILTER_ACCEPT, then
                 //     set the currentNode attribute to node and return node."
                 loop {
-                    let result = try!(self.accept_node(node));
+                    let result = try!(self.accept_node(node.r()));
                     match result {
                         NodeFilterConstants::FILTER_REJECT => break,
                         _ if node.GetFirstChild().is_some() =>
-                            node = node.GetLastChild().unwrap().root()
-                                       .get_unsound_ref_forever(),
+                            node = node.GetLastChild().unwrap(),
                         NodeFilterConstants::FILTER_ACCEPT => {
-                            self.current_node.set(JS::from_rooted(node));
-                            return Ok(Some(Temporary::from_rooted(node)))
+                            self.current_node.set(JS::from_rooted(&node));
+                            return Ok(Some(node))
                         },
                         _ => break
                     }
@@ -182,23 +182,23 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
                 sibling_op = node.GetPreviousSibling()
             }
             // "3. If node is root or node's parent is null, return null."
-            if self.is_root_node(node) || node.GetParentNode().is_none() {
+            if self.is_root_node(node.r()) || node.GetParentNode().is_none() {
                 return Ok(None)
             }
             // "4. Set node to its parent."
-            match node.GetParentNode() {
+            match node.r().GetParentNode() {
                 None =>
                     // This can happen if the user set the current node to somewhere
                     // outside of the tree rooted at the original root.
                     return Ok(None),
-                Some(n) => node = n.root().get_unsound_ref_forever()
+                Some(n) => node = n
             }
             // "5. Filter node and if the return value is FILTER_ACCEPT, then
             //     set the currentNode attribute to node and return node."
-            match try!(self.accept_node(node)) {
+            match try!(self.accept_node(node.r())) {
                 NodeFilterConstants::FILTER_ACCEPT => {
-                    self.current_node.set(JS::from_rooted(node));
-                    return Ok(Some(Temporary::from_rooted(node)))
+                    self.current_node.set(JS::from_rooted(&node));
+                    return Ok(Some(node))
                 },
                 _ => {}
             }
@@ -208,9 +208,9 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
     }
 
     // https://dom.spec.whatwg.org/#dom-treewalker-nextnode
-    fn NextNode(self) -> Fallible<Option<Temporary<Node>>> {
+    fn NextNode(self) -> Fallible<Option<Root<Node>>> {
         // "1. Let node be the value of the currentNode attribute."
-        let mut node = self.current_node.get().root().get_unsound_ref_forever();
+        let mut node = self.current_node.get().root();
         // "2. Let result be FILTER_ACCEPT."
         let mut result = NodeFilterConstants::FILTER_ACCEPT;
         // "3. Run these substeps:"
@@ -221,19 +221,19 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
                     NodeFilterConstants::FILTER_REJECT => break,
                     _ => {}
                 }
-                match node.GetFirstChild() {
+                match node.r().GetFirstChild() {
                     None => break,
                     Some (child) => {
                         // "1. Set node to its first child."
-                        node = child.root().get_unsound_ref_forever();
+                        node = child;
                         // "2. Filter node and set result to the return value."
-                        result = try!(self.accept_node(node));
+                        result = try!(self.accept_node(node.r()));
                         // "3. If result is FILTER_ACCEPT, then
                         //     set the currentNode attribute to node and return node."
                         match result {
                             NodeFilterConstants::FILTER_ACCEPT => {
-                                self.current_node.set(JS::from_rooted(node));
-                                return Ok(Some(Temporary::from_rooted(node)))
+                                self.current_node.set(JS::from_rooted(&node));
+                                return Ok(Some(node))
                             },
                             _ => {}
                         }
@@ -243,18 +243,18 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
             // "2. If a node is following node and is not following root,
             //     set node to the first such node."
             // "Otherwise, return null."
-            match self.first_following_node_not_following_root(node) {
+            match self.first_following_node_not_following_root(node.r()) {
                 None => return Ok(None),
                 Some(n) => {
-                    node = n.root().get_unsound_ref_forever();
+                    node = n;
                     // "3. Filter node and set result to the return value."
-                    result = try!(self.accept_node(node));
+                    result = try!(self.accept_node(node.r()));
                     // "4. If result is FILTER_ACCEPT, then
                     //     set the currentNode attribute to node and return node."
                     match result {
                         NodeFilterConstants::FILTER_ACCEPT => {
-                            self.current_node.set(JS::from_rooted(node));
-                            return Ok(Some(Temporary::from_rooted(node)))
+                            self.current_node.set(JS::from_rooted(&node));
+                            return Ok(Some(node))
                         },
                         _ => {}
                     }
@@ -265,102 +265,95 @@ impl<'a> TreeWalkerMethods for JSRef<'a, TreeWalker> {
     }
 }
 
-type NodeAdvancer<'a> = Fn(JSRef<'a, Node>) -> Option<Temporary<Node>> + 'a;
+type NodeAdvancer<'a> = Fn(&Node) -> Option<Root<Node>> + 'a;
 
 trait PrivateTreeWalkerHelpers {
     fn traverse_children<F, G>(self,
                                next_child: F,
                                next_sibling: G)
-                               -> Fallible<Option<Temporary<Node>>>
-        where F: Fn(JSRef<Node>) -> Option<Temporary<Node>>,
-              G: Fn(JSRef<Node>) -> Option<Temporary<Node>>;
+                               -> Fallible<Option<Root<Node>>>
+        where F: Fn(&Node) -> Option<Root<Node>>,
+              G: Fn(&Node) -> Option<Root<Node>>;
     fn traverse_siblings<F, G>(self,
                                next_child: F,
                                next_sibling: G)
-                               -> Fallible<Option<Temporary<Node>>>
-        where F: Fn(JSRef<Node>) -> Option<Temporary<Node>>,
-              G: Fn(JSRef<Node>) -> Option<Temporary<Node>>;
-    fn is_root_node(self, node: JSRef<Node>) -> bool;
-    fn is_current_node(self, node: JSRef<Node>) -> bool;
-    fn first_following_node_not_following_root(self, node: JSRef<Node>)
-                                               -> Option<Temporary<Node>>;
-    fn accept_node(self, node: JSRef<Node>) -> Fallible<u16>;
+                               -> Fallible<Option<Root<Node>>>
+        where F: Fn(&Node) -> Option<Root<Node>>,
+              G: Fn(&Node) -> Option<Root<Node>>;
+    fn is_root_node(self, node: &Node) -> bool;
+    fn is_current_node(self, node: &Node) -> bool;
+    fn first_following_node_not_following_root(self, node: &Node)
+                                               -> Option<Root<Node>>;
+    fn accept_node(self, node: &Node) -> Fallible<u16>;
 }
 
-impl<'a> PrivateTreeWalkerHelpers for JSRef<'a, TreeWalker> {
+impl<'a> PrivateTreeWalkerHelpers for &'a TreeWalker {
     // https://dom.spec.whatwg.org/#concept-traverse-children
     fn traverse_children<F, G>(self,
                                next_child: F,
                                next_sibling: G)
-                               -> Fallible<Option<Temporary<Node>>>
-        where F: Fn(JSRef<Node>) -> Option<Temporary<Node>>,
-              G: Fn(JSRef<Node>) -> Option<Temporary<Node>>
+                               -> Fallible<Option<Root<Node>>>
+        where F: Fn(&Node) -> Option<Root<Node>>,
+              G: Fn(&Node) -> Option<Root<Node>>
     {
         // "To **traverse children** of type *type*, run these steps:"
         // "1. Let node be the value of the currentNode attribute."
         // "2. Set node to node's first child if type is first, and node's last child if type is last."
         let cur = self.current_node.get().root();
-        let mut node_op: Option<JSRef<Node>> = next_child(cur.r()).map(|node| node.root().get_unsound_ref_forever());
+        let mut node = match next_child(cur.r()) {
+            Some(node) => node,
+            None => return Ok(None),
+        };
 
         // 3. Main: While node is not null, run these substeps:
         'main: loop {
-            match node_op {
-                None => break,
-                Some(node) => {
-                    // "1. Filter node and let result be the return value."
-                    let result = try!(self.accept_node(node));
-                    match result {
-                        // "2. If result is FILTER_ACCEPT, then set the currentNode
-                        //     attribute to node and return node."
-                        NodeFilterConstants::FILTER_ACCEPT => {
-                            self.current_node.set(JS::from_rooted(node));
-                            return Ok(Some(Temporary::from_rooted(node)))
+            // "1. Filter node and let result be the return value."
+            let result = try!(self.accept_node(node.r()));
+            match result {
+                // "2. If result is FILTER_ACCEPT, then set the currentNode
+                //     attribute to node and return node."
+                NodeFilterConstants::FILTER_ACCEPT => {
+                    self.current_node.set(JS::from_rooted(&node));
+                    return Ok(Some(Root::from_ref(node.r())))
+                },
+                // "3. If result is FILTER_SKIP, run these subsubsteps:"
+                NodeFilterConstants::FILTER_SKIP => {
+                    // "1. Let child be node's first child if type is first,
+                    //     and node's last child if type is last."
+                    match next_child(node.r()) {
+                        // "2. If child is not null, set node to child and goto Main."
+                        Some(child) => {
+                            node = child;
+                            continue 'main
                         },
-                        // "3. If result is FILTER_SKIP, run these subsubsteps:"
-                        NodeFilterConstants::FILTER_SKIP => {
-                            // "1. Let child be node's first child if type is first,
-                            //     and node's last child if type is last."
-                            match next_child(node) {
-                                // "2. If child is not null, set node to child and goto Main."
-                                Some(child) => {
-                                    node_op = Some(child.root().get_unsound_ref_forever());
-                                    continue 'main
-                                },
-                                None => {}
-                            }
-                        },
-                        _ => {}
+                        None => {}
                     }
-                    // "4. While node is not null, run these substeps:"
-                    loop {
-                        match node_op {
-                            None => break,
-                            Some(node) => {
-                                // "1. Let sibling be node's next sibling if type is next,
-                                //     and node's previous sibling if type is previous."
-                                match next_sibling(node) {
-                                    // "2. If sibling is not null,
-                                    //     set node to sibling and goto Main."
-                                    Some(sibling) => {
-                                        node_op = Some(sibling.root().get_unsound_ref_forever());
-                                        continue 'main
-                                    },
-                                    None => {
-                                        // "3. Let parent be node's parent."
-                                        match node.GetParentNode().map(|p| p.root().get_unsound_ref_forever()) {
-                                            // "4. If parent is null, parent is root,
-                                            //     or parent is currentNode attribute's value,
-                                            //     return null."
-                                            None => return Ok(None),
-                                            Some(parent) if self.is_root_node(parent)
-                                                            || self.is_current_node(parent) =>
-                                                             return Ok(None),
-                                            // "5. Otherwise, set node to parent."
-                                            Some(parent) => node_op = Some(parent)
-                                        }
-                                    }
-                                }
-                            }
+                },
+                _ => {}
+            }
+            // "4. While node is not null, run these substeps:"
+            loop {
+                // "1. Let sibling be node's next sibling if type is next,
+                //     and node's previous sibling if type is previous."
+                match next_sibling(node.r()) {
+                    // "2. If sibling is not null,
+                    //     set node to sibling and goto Main."
+                    Some(sibling) => {
+                        node = sibling;
+                        continue 'main
+                    },
+                    None => {
+                        // "3. Let parent be node's parent."
+                        match node.GetParentNode() {
+                            // "4. If parent is null, parent is root,
+                            //     or parent is currentNode attribute's value,
+                            //     return null."
+                            None => return Ok(None),
+                            Some(ref parent) if self.is_root_node(parent.r())
+                                            || self.is_current_node(parent.r()) =>
+                                             return Ok(None),
+                            // "5. Otherwise, set node to parent."
+                            Some(parent) => node = parent
                         }
                     }
                 }
@@ -374,58 +367,58 @@ impl<'a> PrivateTreeWalkerHelpers for JSRef<'a, TreeWalker> {
     fn traverse_siblings<F, G>(self,
                                next_child: F,
                                next_sibling: G)
-                               -> Fallible<Option<Temporary<Node>>>
-        where F: Fn(JSRef<Node>) -> Option<Temporary<Node>>,
-              G: Fn(JSRef<Node>) -> Option<Temporary<Node>>
+                               -> Fallible<Option<Root<Node>>>
+        where F: Fn(&Node) -> Option<Root<Node>>,
+              G: Fn(&Node) -> Option<Root<Node>>
     {
         // "To **traverse siblings** of type *type* run these steps:"
         // "1. Let node be the value of the currentNode attribute."
-        let mut node = self.current_node.get().root().get_unsound_ref_forever();
+        let mut node = self.current_node.get().root();
         // "2. If node is root, return null."
-        if self.is_root_node(node) {
+        if self.is_root_node(node.r()) {
             return Ok(None)
         }
         // "3. Run these substeps:"
         loop {
             // "1. Let sibling be node's next sibling if type is next,
             //  and node's previous sibling if type is previous."
-            let mut sibling_op = next_sibling(node);
+            let mut sibling_op = next_sibling(node.r());
             // "2. While sibling is not null, run these subsubsteps:"
             while sibling_op.is_some() {
                 // "1. Set node to sibling."
-                node = sibling_op.unwrap().root().get_unsound_ref_forever();
+                node = sibling_op.unwrap();
                 // "2. Filter node and let result be the return value."
-                let result = try!(self.accept_node(node));
+                let result = try!(self.accept_node(node.r()));
                 // "3. If result is FILTER_ACCEPT, then set the currentNode
                 //     attribute to node and return node."
                 match result {
                     NodeFilterConstants::FILTER_ACCEPT => {
-                        self.current_node.set(JS::from_rooted(node));
-                        return Ok(Some(Temporary::from_rooted(node)))
+                        self.current_node.set(JS::from_rooted(&node));
+                        return Ok(Some(node))
                     },
                     _ => {}
                 }
                 // "4. Set sibling to node's first child if type is next,
                 //     and node's last child if type is previous."
-                sibling_op = next_child(node);
+                sibling_op = next_child(node.r());
                 // "5. If result is FILTER_REJECT or sibling is null,
                 //     then set sibling to node's next sibling if type is next,
                 //     and node's previous sibling if type is previous."
                 match (result, &sibling_op) {
                     (NodeFilterConstants::FILTER_REJECT, _)
-                    | (_, &None) => sibling_op = next_sibling(node),
+                    | (_, &None) => sibling_op = next_sibling(node.r()),
                     _ => {}
                 }
             }
             // "3. Set node to its parent."
-            match node.GetParentNode().map(|p| p.root().get_unsound_ref_forever()) {
+            match node.GetParentNode() {
                 // "4. If node is null or is root, return null."
                 None => return Ok(None),
-                Some(n) if self.is_root_node(n) => return Ok(None),
+                Some(ref n) if self.is_root_node(n.r()) => return Ok(None),
                 // "5. Filter node and if the return value is FILTER_ACCEPT, then return null."
                 Some(n) => {
                     node = n;
-                    match try!(self.accept_node(node)) {
+                    match try!(self.accept_node(node.r())) {
                         NodeFilterConstants::FILTER_ACCEPT => return Ok(None),
                         _ => {}
                     }
@@ -436,23 +429,23 @@ impl<'a> PrivateTreeWalkerHelpers for JSRef<'a, TreeWalker> {
     }
 
     // https://dom.spec.whatwg.org/#concept-tree-following
-    fn first_following_node_not_following_root(self, node: JSRef<Node>)
-                                               -> Option<Temporary<Node>> {
+    fn first_following_node_not_following_root(self, node: &Node)
+                                               -> Option<Root<Node>> {
         // "An object A is following an object B if A and B are in the same tree
         //  and A comes after B in tree order."
         match node.GetNextSibling() {
             None => {
-                let mut candidate = node;
-                while !self.is_root_node(candidate) && candidate.GetNextSibling().is_none() {
+                let mut candidate = Root::from_ref(node);
+                while !self.is_root_node(candidate.r()) && candidate.GetNextSibling().is_none() {
                     match candidate.GetParentNode() {
                         None =>
                             // This can happen if the user set the current node to somewhere
                             // outside of the tree rooted at the original root.
                             return None,
-                        Some(n) => candidate = n.root().get_unsound_ref_forever()
+                        Some(n) => candidate = n
                     }
                 }
-                if self.is_root_node(candidate) {
+                if self.is_root_node(candidate.r()) {
                     None
                 } else {
                     candidate.GetNextSibling()
@@ -463,7 +456,7 @@ impl<'a> PrivateTreeWalkerHelpers for JSRef<'a, TreeWalker> {
     }
 
     // https://dom.spec.whatwg.org/#concept-node-filter
-    fn accept_node(self, node: JSRef<Node>) -> Fallible<u16> {
+    fn accept_node(self, node: &Node) -> Fallible<u16> {
         // "To filter node run these steps:"
         // "1. Let n be node's nodeType attribute value minus 1."
         let n = node.NodeType() - 1;
@@ -479,25 +472,25 @@ impl<'a> PrivateTreeWalkerHelpers for JSRef<'a, TreeWalker> {
         match self.filter {
             Filter::None => Ok(NodeFilterConstants::FILTER_ACCEPT),
             Filter::Native(f) => Ok((f)(node)),
-            Filter::JS(callback) => callback.AcceptNode_(self, node, Rethrow)
+            Filter::JS(ref callback) => callback.AcceptNode_(self, node, Rethrow)
         }
     }
 
-    fn is_root_node(self, node: JSRef<Node>) -> bool {
-        JS::from_rooted(node) == self.root_node
+    fn is_root_node(self, node: &Node) -> bool {
+        JS::from_ref(node) == self.root_node
     }
 
-    fn is_current_node(self, node: JSRef<Node>) -> bool {
-        JS::from_rooted(node) == self.current_node.get()
+    fn is_current_node(self, node: &Node) -> bool {
+        JS::from_ref(node) == self.current_node.get()
     }
 }
 
-impl<'a> Iterator for JSRef<'a, TreeWalker> {
-    type Item = JSRef<'a, Node>;
+impl<'a> Iterator for &'a TreeWalker {
+    type Item = Root<Node>;
 
-    fn next(&mut self) -> Option<JSRef<'a, Node>> {
+    fn next(&mut self) -> Option<Root<Node>> {
         match self.NextNode() {
-            Ok(node) => node.map(|n| n.root().get_unsound_ref_forever()),
+            Ok(node) => node,
             Err(_) =>
                 // The Err path happens only when a JavaScript
                 // NodeFilter throws an exception. This iterator
@@ -512,6 +505,6 @@ impl<'a> Iterator for JSRef<'a, TreeWalker> {
 #[jstraceable]
 pub enum Filter {
     None,
-    Native(fn (node: JSRef<Node>) -> u16),
-    JS(NodeFilter)
+    Native(fn (node: &Node) -> u16),
+    JS(Rc<NodeFilter>)
 }