Refactor parallel dom traversal to be agnostic to the processing steps themselves.

1 files changed, 13 insertions, 19 deletions

diff --git a/components/layout/sequential.rs b/components/layout/sequential.rs
index 5f33e5f352c..310560e2fa7 100644
--- a/components/layout/sequential.rs
+++ b/components/layout/sequential.rs
@@ -14,39 +14,33 @@ use fragment::FragmentBorderBoxIterator;
 use generated_content::ResolveGeneratedContent;
 use traversal::PostorderNodeMutTraversal;
 use traversal::{AssignBSizesAndStoreOverflow, AssignISizes};
-use traversal::{BubbleISizes, ConstructFlows, RecalcStyleForNode};
-use traversal::{BuildDisplayList, ComputeAbsolutePositions};
-use traversal::{PostorderDomTraversal, PreorderDomTraversal};
+use traversal::{BubbleISizes, BuildDisplayList, ComputeAbsolutePositions};
+use traversal::{DomTraversal, DomTraversalContext};
 use util::opts;
 use wrapper::LayoutNode;
 
-pub fn traverse_dom_preorder<'le, N>(root: N,
-                                     shared_layout_context: &SharedLayoutContext)
-                                     where N: LayoutNode<'le> {
-    fn doit<'le, N>(node: N,
-                    recalc_style: RecalcStyleForNode,
-                    construct_flows: ConstructFlows)
-                    where N: LayoutNode<'le> {
-        recalc_style.process(node);
+pub fn traverse_dom_preorder<'ln, N, T>(root: N,
+                                        shared_layout_context: &SharedLayoutContext)
+                                        where N: LayoutNode<'ln>,
+                                              T: DomTraversal<'ln, N> {
+    fn doit<'a, 'ln, N, T>(context: &'a DomTraversalContext<'a>, node: N)
+                           where N: LayoutNode<'ln>, T: DomTraversal<'ln, N> {
+        T::process_preorder(context, node);
 
         for kid in node.children() {
-            doit(kid, recalc_style, construct_flows);
+            doit::<N, T>(context, kid);
         }
 
-        construct_flows.process(node);
+        T::process_postorder(context, node);
     }
 
     let layout_context = LayoutContext::new(shared_layout_context);
-    let recalc_style = RecalcStyleForNode {
-        layout_context: &layout_context,
-        root: root.opaque(),
-    };
-    let construct_flows = ConstructFlows {
+    let traversal_context = DomTraversalContext {
         layout_context: &layout_context,
         root: root.opaque(),
     };
 
-    doit::<'le, N>(root, recalc_style, construct_flows);
+    doit::<N, T>(&traversal_context, root);
 }
 
 pub fn resolve_generated_content(root: &mut FlowRef, shared_layout_context: &SharedLayoutContext) {