From c40cf9a15ae4c1262062532fc98ae5320058d68d Mon Sep 17 00:00:00 2001
From: Simon Sapin <simon.sapin@exyr.org>
Date: Wed, 17 Feb 2016 10:48:42 +0100
Subject: [PATCH 1/4] ignore_missing_rules is obsolete, all rules are
 implemented now

---
 src/tree_builder/mod.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/src/tree_builder/mod.rs b/src/tree_builder/mod.rs
index 3c68b1a4..5bbc1027 100644
--- a/src/tree_builder/mod.rs
+++ b/src/tree_builder/mod.rs
@@ -57,14 +57,7 @@ pub struct TreeBuilderOpts {
     /// Should we drop the DOCTYPE (if any) from the tree?
     pub drop_doctype: bool,
 
-    /// The `<svg>`, `<math>`, and `<template>` tags have special
-    /// parsing rules that are currently unimplemented.  By default
-    /// we `panic!()` if any of these tags is encountered.  If this
-    /// option is enabled, we will instead attempt to parse them
-    /// using the ordinary HTML parsing rules.
-    ///
-    /// **Warning**: This may produce extremely incorrect results
-    /// on some documents!
+    /// Obsolete, ignored.
     pub ignore_missing_rules: bool,
 
     /// Initial TreeBuilder quirks mode. Default: NoQuirks

From cb8c4f1a7bda567363658e570b48468aa99cd717 Mon Sep 17 00:00:00 2001
From: Simon Sapin <simon.sapin@exyr.org>
Date: Wed, 17 Feb 2016 10:49:24 +0100
Subject: [PATCH 2/4] Add a lower-level API for parse_fragment in the driver
 module

---
 src/driver.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/driver.rs b/src/driver.rs
index fcb3c4c2..fe87c326 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -56,7 +56,17 @@ pub fn parse_fragment<Sink>(mut sink: Sink, opts: ParseOpts,
                             -> Parser<Sink>
                             where Sink: TreeSink {
     let context_elem = sink.create_element(context_name, context_attrs);
-    let tb = TreeBuilder::new_for_fragment(sink, context_elem, None, opts.tree_builder);
+    parse_fragment_for_element(sink, opts, context_elem, None)
+}
+
+/// Like `parse_fragment`, but with an existing context element
+/// and optionally a form element.
+pub fn parse_fragment_for_element<Sink>(sink: Sink, opts: ParseOpts,
+                                        context_element: Sink::Handle,
+                                        form_element: Option<Sink::Handle>)
+                                        -> Parser<Sink>
+                                        where Sink: TreeSink {
+    let tb = TreeBuilder::new_for_fragment(sink, context_element, form_element, opts.tree_builder);
     let tok_opts = TokenizerOpts {
         initial_state: Some(tb.tokenizer_state_for_context_elem()),
         .. opts.tokenizer

From afcb6441672f29741b7cab2d172580b1ad74711a Mon Sep 17 00:00:00 2001
From: Simon Sapin <simon.sapin@exyr.org>
Date: Wed, 17 Feb 2016 10:49:42 +0100
Subject: [PATCH 3/4] Have Parser and BytesParser expose their tokenizer

---
 Cargo.toml    |  4 ++--
 src/driver.rs | 22 +++++++++++++++++++++-
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ee3fbcb8..5b651714 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 
 name = "html5ever"
-version = "0.5.1"
+version = "0.5.2"
 authors = [ "The html5ever Project Developers" ]
 license = "MIT / Apache-2.0"
 repository = "https://github.com/servo/html5ever"
@@ -37,7 +37,7 @@ log = "0"
 phf = "0.7"
 string_cache = "0.2.0"
 mac = "0"
-tendril = "0.2"
+tendril = "0.2.2"
 heapsize = { version = ">=0.1.1, <0.4", optional = true }
 heapsize_plugin = { version = "0.1.0", optional = true }
 
diff --git a/src/driver.rs b/src/driver.rs
index fe87c326..2be61dd3 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -78,7 +78,7 @@ pub fn parse_fragment_for_element<Sink>(sink: Sink, opts: ParseOpts,
 /// An HTML parser,
 /// ready to recieve Unicode input through the `tendril::TendrilSink` trait’s methods.
 pub struct Parser<Sink> where Sink: TreeSink {
-    tokenizer: Tokenizer<TreeBuilder<Sink::Handle, Sink>>,
+    pub tokenizer: Tokenizer<TreeBuilder<Sink::Handle, Sink>>,
 }
 
 impl<Sink: TreeSink> TendrilSink<tendril::fmt::UTF8> for Parser<Sink> {
@@ -157,6 +157,26 @@ enum BytesParserState<Sink> where Sink: TreeSink {
     Transient
 }
 
+impl<Sink: TreeSink> BytesParser<Sink> {
+    pub fn str_parser(&self) -> &Parser<Sink> {
+        match self.state {
+            BytesParserState::Initial { ref parser } => parser,
+            BytesParserState::Buffering { ref parser, .. } => parser,
+            BytesParserState::Parsing { ref decoder } => decoder.inner_sink(),
+            BytesParserState::Transient => unreachable!(),
+        }
+    }
+
+    pub fn str_parser_mut(&mut self) -> &mut Parser<Sink> {
+        match self.state {
+            BytesParserState::Initial { ref mut parser } => parser,
+            BytesParserState::Buffering { ref mut parser, .. } => parser,
+            BytesParserState::Parsing { ref mut decoder } => decoder.inner_sink_mut(),
+            BytesParserState::Transient => unreachable!(),
+        }
+    }
+}
+
 impl<Sink: TreeSink> TendrilSink<tendril::fmt::Bytes> for BytesParser<Sink> {
     fn process(&mut self, t: ByteTendril) {
         if let &mut BytesParserState::Parsing { ref mut decoder } = &mut self.state {

From 4b74e4c54c433f0a1a827b6e356464711146c153 Mon Sep 17 00:00:00 2001
From: Simon Sapin <simon.sapin@exyr.org>
Date: Wed, 17 Feb 2016 11:51:53 +0100
Subject: [PATCH 4/4] Add BytesParser::process_unicode

---
 src/driver.rs | 39 +++++++++++++++++++++++++++++++++++----
 1 file changed, 35 insertions(+), 4 deletions(-)

diff --git a/src/driver.rs b/src/driver.rs
index 2be61dd3..ec7e35bd 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -158,6 +158,7 @@ enum BytesParserState<Sink> where Sink: TreeSink {
 }
 
 impl<Sink: TreeSink> BytesParser<Sink> {
+    /// Access the underlying Parser
     pub fn str_parser(&self) -> &Parser<Sink> {
         match self.state {
             BytesParserState::Initial { ref parser } => parser,
@@ -167,6 +168,7 @@ impl<Sink: TreeSink> BytesParser<Sink> {
         }
     }
 
+    /// Access the underlying Parser
     pub fn str_parser_mut(&mut self) -> &mut Parser<Sink> {
         match self.state {
             BytesParserState::Initial { ref mut parser } => parser,
@@ -175,6 +177,38 @@ impl<Sink: TreeSink> BytesParser<Sink> {
             BytesParserState::Transient => unreachable!(),
         }
     }
+
+    /// Insert a Unicode chunk in the middle of the byte stream.
+    ///
+    /// This is e.g. for supporting `document.write`.
+    pub fn process_unicode(&mut self, t: StrTendril) {
+        if let BytesParserState::Parsing { ref mut decoder } = self.state {
+            decoder.inner_sink_mut().process(t)
+        } else {
+            match mem::replace(&mut self.state, BytesParserState::Transient) {
+                BytesParserState::Initial { mut parser } => {
+                    parser.process(t);
+                    self.start_parsing(parser, ByteTendril::new())
+                }
+                BytesParserState::Buffering { parser, buffer } => {
+                    self.start_parsing(parser, buffer);
+                    if let BytesParserState::Parsing { ref mut decoder } = self.state {
+                        decoder.inner_sink_mut().process(t)
+                    } else {
+                        unreachable!()
+                    }
+                }
+                BytesParserState::Parsing { .. } | BytesParserState::Transient => unreachable!(),
+            }
+        }
+    }
+
+    fn start_parsing(&mut self, parser: Parser<Sink>, buffer: ByteTendril) {
+        let encoding = detect_encoding(&buffer, &self.opts);
+        let mut decoder = LossyDecoder::new(encoding, parser);
+        decoder.process(buffer);
+        self.state = BytesParserState::Parsing { decoder: decoder }
+    }
 }
 
 impl<Sink: TreeSink> TendrilSink<tendril::fmt::Bytes> for BytesParser<Sink> {
@@ -191,10 +225,7 @@ impl<Sink: TreeSink> TendrilSink<tendril::fmt::Bytes> for BytesParser<Sink> {
             BytesParserState::Parsing { .. } | BytesParserState::Transient => unreachable!(),
         };
         if buffer.len32() >= PRESCAN_BYTES {
-            let encoding = detect_encoding(&buffer, &self.opts);
-            let mut decoder = LossyDecoder::new(encoding, parser);
-            decoder.process(buffer);
-            self.state = BytesParserState::Parsing { decoder: decoder }
+            self.start_parsing(parser, buffer)
         } else {
             self.state = BytesParserState::Buffering {
                 parser: parser,