1 files changed, 28 insertions, 18 deletions

diff --git a/components/style/sequential.rs b/components/style/sequential.rs
index 0e5253b2073..b47d95a8517 100644
--- a/components/style/sequential.rs
+++ b/components/style/sequential.rs
@@ -4,42 +4,52 @@
 
 //! Implements sequential traversal over the DOM tree.
 
-use dom::TNode;
-use traversal::{DomTraversalContext, PerLevelTraversalData};
+use dom::{TElement, TNode};
+use traversal::{DomTraversal, PerLevelTraversalData, PreTraverseToken};
 
-pub fn traverse_dom<N, C>(root: N,
-                          shared: &C::SharedContext)
+pub fn traverse_dom<N, D>(traversal: &D,
+                          root: N::ConcreteElement,
+                          token: PreTraverseToken)
     where N: TNode,
-          C: DomTraversalContext<N>
+          D: DomTraversal<N>
 {
-    fn doit<'a, N, C>(context: &'a C, node: N, data: &mut PerLevelTraversalData)
+    debug_assert!(token.should_traverse());
+
+    fn doit<N, D>(traversal: &D, traversal_data: &mut PerLevelTraversalData,
+                  thread_local: &mut D::ThreadLocalContext, node: N)
         where N: TNode,
-              C: DomTraversalContext<N>
+              D: DomTraversal<N>
     {
-        context.process_preorder(node, data);
+        traversal.process_preorder(traversal_data, thread_local, node);
         if let Some(el) = node.as_element() {
-            if let Some(ref mut depth) = data.current_dom_depth {
+            if let Some(ref mut depth) = traversal_data.current_dom_depth {
                 *depth += 1;
             }
 
-            C::traverse_children(el, |kid| doit::<N, C>(context, kid, data));
+            D::traverse_children(el, |kid| doit(traversal, traversal_data, thread_local, kid));
 
-            if let Some(ref mut depth) = data.current_dom_depth {
+            if let Some(ref mut depth) = traversal_data.current_dom_depth {
                 *depth -= 1;
             }
         }
 
-        if context.needs_postorder_traversal() {
-            context.process_postorder(node);
+        if D::needs_postorder_traversal() {
+            traversal.process_postorder(thread_local, node);
         }
     }
 
-    let mut data = PerLevelTraversalData {
+    let mut traversal_data = PerLevelTraversalData {
         current_dom_depth: None,
     };
-    let context = C::new(shared, root.opaque());
-    doit::<N, C>(&context, root, &mut data);
 
-    // Clear the local LRU cache since we store stateful elements inside.
-    context.local_context().style_sharing_candidate_cache.borrow_mut().clear();
+    let mut tlc = traversal.create_thread_local_context();
+    if token.traverse_unstyled_children_only() {
+        for kid in root.as_node().children() {
+            if kid.as_element().map_or(false, |el| el.get_data().is_none()) {
+                doit(traversal, &mut traversal_data, &mut tlc, kid);
+            }
+        }
+    } else {
+        doit(traversal, &mut traversal_data, &mut tlc, root.as_node());
+    }
 }