Auto merge of #300 - cynicaldevil:remove-dep-on-sync-methods, r=nox

TreeBuilder no longer relies on `same_tree` and `has_parent_node`

The use of `same_tree` and `has_parent_node` meant that the TreeBuilder needed access to the DOM state to carry out its tasks.

Author: bors-servo

html5ever/examples/noop-tree-builder.rs

@@ -86,6 +86,11 @@ impl TreeSink for Sink {
             _sibling: &usize,
             _new_node: NodeOrText<usize>) { }
 
+    fn append_based_on_parent_node(&mut self,
+        _element: &usize,
+        _prev_element: &usize,
+        _new_node: NodeOrText<usize>) { }
+
     fn parse_error(&mut self, _msg: Cow<'static, str>) { }
     fn set_quirks_mode(&mut self, _mode: QuirksMode) { }
     fn append(&mut self, _parent: &usize, _child: NodeOrText<usize>) { }

html5ever/examples/print-tree-actions.rs

@@ -109,6 +109,18 @@ impl TreeSink for Sink {
         }
     }
 
+    fn append_based_on_parent_node(&mut self,
+        element: &Self::Handle,
+        prev_element: &Self::Handle,
+        child: NodeOrText<Self::Handle>) {
+
+        if self.has_parent_node(element) {
+            self.append_before_sibling(element, child);
+        } else {
+            self.append(prev_element, child);
+        }
+    }
+
     fn append_doctype_to_document(&mut self,
                                   name: StrTendril,
                                   public_id: StrTendril,
@@ -124,7 +136,7 @@ impl TreeSink for Sink {
         }
     }
 
-    fn associate_with_form(&mut self, _target: &usize, _form: &usize) {
+    fn associate_with_form(&mut self, _target: &usize, _form: &usize, _nodes: (&usize, Option<&usize>)) {
         // No form owner support. Since same_tree always returns
         // true we cannot be sure that this associate_with_form call is
         // valid

html5ever/src/tree_builder/mod.rs

@@ -386,15 +386,10 @@ impl<Handle, Sink> TreeBuilder<Handle, Sink>
                 let contents = self.sink.get_template_contents(&elem);
                 return LastChild(contents);
             } else if self.html_elem_named(&elem, local_name!("table")) {
-                // Try inserting "inside last table's parent node, immediately before last table"
-                if self.sink.has_parent_node(&elem) {
-                    return BeforeSibling(elem.clone());
-                } else {
-                    // If elem has no parent, we regain ownership of the child.
-                    // Insert "inside previous element, after its last child (if any)"
-                    let previous_element = (*iter.peek().unwrap()).clone();
-                    return LastChild(previous_element);
-                }
+                return TableFosterParenting {
+                    element: elem.clone(),
+                    prev_element: (*iter.peek().unwrap()).clone(),
+                };
             }
         }
         let html_elem = self.html_elem();
@@ -404,7 +399,11 @@ impl<Handle, Sink> TreeBuilder<Handle, Sink>
     fn insert_at(&mut self, insertion_point: InsertionPoint<Handle>, child: NodeOrText<Handle>) {
         match insertion_point {
             LastChild(parent) => self.sink.append(&parent, child),
-            BeforeSibling(sibling) => self.sink.append_before_sibling(&sibling, child)
+            BeforeSibling(sibling) => self.sink.append_before_sibling(&sibling, child),
+            TableFosterParenting { element, prev_element } => self.sink.append_based_on_parent_node(
+                                                                  &element,
+                                                                  &prev_element,
+                                                                  child),
         }
     }
 }
@@ -1178,9 +1177,10 @@ impl<Handle, Sink> TreeBuilder<Handle, Sink>
         let elem = create_element(&mut self.sink, qname.clone(), attrs.clone());
 
         let insertion_point = self.appropriate_place_for_insertion(None);
-        let tree_node = match insertion_point {
+        let (node1, node2) = match insertion_point {
             LastChild(ref p) |
-            BeforeSibling(ref p) => p.clone()
+            BeforeSibling(ref p) => (p.clone(), None),
+            TableFosterParenting { ref element, ref prev_element } => (element.clone(), Some(prev_element.clone())),
         };
 
         // Step 12.
@@ -1190,10 +1190,12 @@ impl<Handle, Sink> TreeBuilder<Handle, Sink>
            !(listed(qname.expanded()) &&
                 attrs.iter().any(|a| a.name.expanded() == expanded_name!("", "form"))) {
 
-               let form = self.form_elem.as_ref().unwrap().clone();
-               if self.sink.same_tree(&tree_node, &form) {
-                   self.sink.associate_with_form(&elem, &form)
-               }
+            let form = self.form_elem.as_ref().unwrap().clone();
+            let node2 = match node2 {
+                Some(ref n) => Some(n),
+                None => None,
+            };
+            self.sink.associate_with_form(&elem, &form, (&node1, node2));
         }
 
         self.insert_at(insertion_point, AppendNode(elem.clone()));
@@ -1644,6 +1646,14 @@ mod test {
             self.rcdom.append_before_sibling(sibling, child)
         }
 
+        fn append_based_on_parent_node(
+            &mut self,
+            element: &Handle,
+            prev_element: &Handle,
+            child: NodeOrText<Handle>) {
+            self.rcdom.append_based_on_parent_node(element, prev_element, child)
+        }
+
         fn append_doctype_to_document(&mut self,
                                       name: StrTendril,
                                       public_id: StrTendril,

html5ever/src/tree_builder/types.rs

@@ -86,5 +86,7 @@ pub enum InsertionPoint<Handle> {
     /// Insert as last child in this parent.
     LastChild(Handle),
     /// Insert before this following sibling.
-    BeforeSibling(Handle)
+    BeforeSibling(Handle),
+    /// Insertion point is decided based on existence of element's parent node.
+    TableFosterParenting { element: Handle, prev_element: Handle },
 }

markup5ever/interface/tree_builder.rs

@@ -140,6 +140,14 @@ pub trait TreeSink {
     /// The child node will not already have a parent.
     fn append(&mut self, parent: &Self::Handle, child: NodeOrText<Self::Handle>);
 
+    /// When the insertion point is decided by the existence of a parent node of the
+    /// element, we consider both possibilities and send the element which will be used
+    /// if a parent node exists, along with the element to be used if there isn't one.
+    fn append_based_on_parent_node(&mut self,
+        element: &Self::Handle,
+        prev_element: &Self::Handle,
+        child: NodeOrText<Self::Handle>);
+
     /// Append a `DOCTYPE` element to the `Document` node.
     fn append_doctype_to_document(&mut self,
                                   name: StrTendril,
@@ -188,7 +196,10 @@ pub trait TreeSink {
     fn add_attrs_if_missing(&mut self, target: &Self::Handle, attrs: Vec<Attribute>);
 
     /// Associate the given form-associatable element with the form element
-    fn associate_with_form(&mut self, _target: &Self::Handle, _form: &Self::Handle) {}
+    fn associate_with_form(&mut self,
+        _target: &Self::Handle,
+        _form: &Self::Handle,
+        _nodes: (&Self::Handle, Option<&Self::Handle>)) {}
 
     /// Detach the given node from its parent.
     fn remove_from_parent(&mut self, target: &Self::Handle);

markup5ever/rcdom.rs

@@ -265,6 +265,18 @@ impl TreeSink for RcDom {
         parent.children.borrow_mut().insert(i, child);
     }
 
+    fn append_based_on_parent_node(&mut self,
+        element: &Self::Handle,
+        prev_element: &Self::Handle,
+        child: NodeOrText<Self::Handle>) {
+
+        if self.has_parent_node(element) {
+            self.append_before_sibling(element, child);
+        } else {
+            self.append(prev_element, child);
+        }
+    }
+
     fn append_doctype_to_document(&mut self,
                                   name: StrTendril,
                                   public_id: StrTendril,