Move rev_children and traverse_preorder to LayoutNode.

These impose additional requirements on the traversal code that we want to
avoid for Gecko (for now).

components/script_layout_interface/wrapper_traits.rs

@@ -80,8 +80,61 @@ pub trait LayoutNode: TNode {
 
     fn init_style_and_layout_data(&self, data: OpaqueStyleAndLayoutData);
     fn get_style_and_layout_data(&self) -> Option<OpaqueStyleAndLayoutData>;
+
+    fn rev_children(self) -> ReverseChildrenIterator<Self> {
+        ReverseChildrenIterator {
+            current: self.last_child(),
+        }
+    }
+
+    fn traverse_preorder(self) -> TreeIterator<Self> {
+        TreeIterator::new(self)
+    }
+}
+
+pub struct ReverseChildrenIterator<ConcreteNode> where ConcreteNode: TNode {
+    current: Option<ConcreteNode>,
+}
+
+impl<ConcreteNode> Iterator for ReverseChildrenIterator<ConcreteNode>
+                            where ConcreteNode: TNode {
+    type Item = ConcreteNode;
+    fn next(&mut self) -> Option<ConcreteNode> {
+        let node = self.current;
+        self.current = node.and_then(|node| node.prev_sibling());
+        node
+    }
+}
+
+pub struct TreeIterator<ConcreteNode> where ConcreteNode: TNode {
+    stack: Vec<ConcreteNode>,
 }
 
+impl<ConcreteNode> TreeIterator<ConcreteNode> where ConcreteNode: LayoutNode {
+    fn new(root: ConcreteNode) -> TreeIterator<ConcreteNode> {
+        let mut stack = vec![];
+        stack.push(root);
+        TreeIterator {
+            stack: stack,
+        }
+    }
+
+    pub fn next_skipping_children(&mut self) -> Option<ConcreteNode> {
+        self.stack.pop()
+    }
+}
+
+impl<ConcreteNode> Iterator for TreeIterator<ConcreteNode>
+                            where ConcreteNode: LayoutNode {
+    type Item = ConcreteNode;
+    fn next(&mut self) -> Option<ConcreteNode> {
+        let ret = self.stack.pop();
+        ret.map(|node| self.stack.extend(node.rev_children()));
+        ret
+    }
+}
+
+
 /// A thread-safe version of `LayoutNode`, used during flow construction. This type of layout
 /// node does not allow any parents or siblings of nodes to be accessed, to avoid races.
 pub trait ThreadSafeLayoutNode: Clone + Copy + Sized + PartialEq {

components/style/dom.rs

@@ -83,23 +83,13 @@ pub trait TNode : Sized + Copy + Clone {
 
     fn dump_style(self);
 
-    fn traverse_preorder(self) -> TreeIterator<Self> {
-        TreeIterator::new(self)
-    }
-
     /// Returns an iterator over this node's children.
     fn children(self) -> ChildrenIterator<Self> {
         ChildrenIterator {
             current: self.first_child(),
         }
     }
 
-    fn rev_children(self) -> ReverseChildrenIterator<Self> {
-        ReverseChildrenIterator {
-            current: self.last_child(),
-        }
-    }
-
     /// Converts self into an `OpaqueNode`.
     fn opaque(&self) -> OpaqueNode;
 
@@ -255,34 +245,6 @@ pub trait TElement : PartialEq + Debug + Sized + Copy + Clone + ElementExt + Pre
     }
 }
 
-pub struct TreeIterator<ConcreteNode> where ConcreteNode: TNode {
-    stack: Vec<ConcreteNode>,
-}
-
-impl<ConcreteNode> TreeIterator<ConcreteNode> where ConcreteNode: TNode {
-    fn new(root: ConcreteNode) -> TreeIterator<ConcreteNode> {
-        let mut stack = vec![];
-        stack.push(root);
-        TreeIterator {
-            stack: stack,
-        }
-    }
-
-    pub fn next_skipping_children(&mut self) -> Option<ConcreteNode> {
-        self.stack.pop()
-    }
-}
-
-impl<ConcreteNode> Iterator for TreeIterator<ConcreteNode>
-                            where ConcreteNode: TNode {
-    type Item = ConcreteNode;
-    fn next(&mut self) -> Option<ConcreteNode> {
-        let ret = self.stack.pop();
-        ret.map(|node| self.stack.extend(node.rev_children()));
-        ret
-    }
-}
-
 pub struct ChildrenIterator<ConcreteNode> where ConcreteNode: TNode {
     current: Option<ConcreteNode>,
 }
@@ -296,17 +258,3 @@ impl<ConcreteNode> Iterator for ChildrenIterator<ConcreteNode>
         node
     }
 }
-
-pub struct ReverseChildrenIterator<ConcreteNode> where ConcreteNode: TNode {
-    current: Option<ConcreteNode>,
-}
-
-impl<ConcreteNode> Iterator for ReverseChildrenIterator<ConcreteNode>
-                            where ConcreteNode: TNode {
-    type Item = ConcreteNode;
-    fn next(&mut self) -> Option<ConcreteNode> {
-        let node = self.current;
-        self.current = node.and_then(|node| node.prev_sibling());
-        node
-    }
-}