auto merge of #5377 : frewsxcv/servo/rm-node-iter, r=jdm

Was introduced in 7aee1cae84

I noticed it isn't actively in use, so unless there's some bigger reason
why it exists, it could probably be removed

components/script/dom/node.rs

@@ -1134,89 +1134,6 @@ impl<'a> Iterator for TreeIterator<'a> {
     }
 }
 
-#[must_root]
-pub struct NodeIterator {
-    pub start_node: JS<Node>,
-    pub current_node: Option<JS<Node>>,
-    pub depth: uint,
-    include_start: bool,
-    include_descendants_of_void: bool
-}
-
-impl NodeIterator {
-    pub fn new<'a>(start_node: JSRef<'a, Node>,
-                   include_start: bool,
-                   include_descendants_of_void: bool) -> NodeIterator {
-        NodeIterator {
-            start_node: JS::from_rooted(start_node),
-            current_node: None,
-            depth: 0,
-            include_start: include_start,
-            include_descendants_of_void: include_descendants_of_void
-        }
-    }
-
-    fn next_child<'b>(&self, node: JSRef<'b, Node>) -> Option<JSRef<'b, Node>> {
-        let skip = |element: JSRef<Element>| {
-            !self.include_descendants_of_void && element.is_void()
-        };
-
-        match ElementCast::to_ref(node) {
-            Some(element) if skip(element) => None,
-            _ => node.first_child().map(|child| child.root().get_unsound_ref_forever()),
-        }
-    }
-}
-
-impl<'a> Iterator for NodeIterator {
-    type Item = JSRef<'a, Node>;
-
-    fn next(&mut self) -> Option<JSRef<'a, Node>> {
-        self.current_node = match self.current_node.as_ref().map(|node| node.root()) {
-            None => {
-                if self.include_start {
-                    Some(self.start_node)
-                } else {
-                    self.next_child(self.start_node.root().r())
-                        .map(|child| JS::from_rooted(child))
-                }
-            },
-            Some(node) => {
-                match self.next_child(node.r()) {
-                    Some(child) => {
-                        self.depth += 1;
-                        Some(JS::from_rooted(child))
-                    },
-                    None if JS::from_rooted(node.r()) == self.start_node => None,
-                    None => {
-                        match node.r().next_sibling().root() {
-                            Some(sibling) => Some(JS::from_rooted(sibling.r())),
-                            None => {
-                                let mut candidate = node.get_unsound_ref_forever();
-                                while candidate.next_sibling().is_none() {
-                                    candidate = candidate.parent_node()
-                                                         .expect("Got to root without reaching start node")
-                                                         .root()
-                                                         .get_unsound_ref_forever();
-                                    if JS::from_rooted(candidate) == self.start_node {
-                                        break;
-                                    }
-                                    self.depth -= 1;
-                                }
-                                if JS::from_rooted(candidate) != self.start_node {
-                                    candidate.next_sibling().map(|node| JS::from_rooted(node.root().r()))
-                                } else {
-                                    None
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        self.current_node.map(|node| node.root().get_unsound_ref_forever())
-    }
-}
 
 /// Specifies whether children must be recursively cloned or not.
 #[derive(Copy, PartialEq)]