Merge script::parse and script::dom::servoparser

components/script/dom/servoparser/html.rs

@@ -0,0 +1,339 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#![allow(unrooted_must_root)]
+
+use document_loader::DocumentLoader;
+use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
+use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
+use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
+use dom::bindings::inheritance::{Castable, CharacterDataTypeId, NodeTypeId};
+use dom::bindings::js::{JS, RootedReference};
+use dom::bindings::str::DOMString;
+use dom::characterdata::CharacterData;
+use dom::comment::Comment;
+use dom::document::{DocumentSource, IsHTMLDocument};
+use dom::document::Document;
+use dom::documenttype::DocumentType;
+use dom::element::{Element, ElementCreator};
+use dom::htmlformelement::HTMLFormElement;
+use dom::htmlscriptelement::HTMLScriptElement;
+use dom::htmltemplateelement::HTMLTemplateElement;
+use dom::node::{document_from_node, window_from_node};
+use dom::node::Node;
+use dom::processinginstruction::ProcessingInstruction;
+use dom::text::Text;
+use html5ever::Attribute;
+use html5ever::serialize::{AttrRef, Serializable, Serializer};
+use html5ever::serialize::TraversalScope;
+use html5ever::serialize::TraversalScope::{ChildrenOnly, IncludeNode};
+use html5ever::tendril::StrTendril;
+use html5ever::tokenizer::{Tokenizer as HtmlTokenizer, TokenizerOpts};
+use html5ever::tree_builder::{NextParserState, NodeOrText, QuirksMode};
+use html5ever::tree_builder::{TreeBuilder, TreeBuilderOpts, TreeSink};
+use msg::constellation_msg::PipelineId;
+use std::borrow::Cow;
+use std::io::{self, Write};
+use string_cache::QualName;
+use super::{LastChunkState, ServoParser, Sink, Tokenizer};
+use url::Url;
+
+fn insert(parent: &Node, reference_child: Option<&Node>, child: NodeOrText<JS<Node>>) {
+    match child {
+        NodeOrText::AppendNode(n) => {
+            assert!(parent.InsertBefore(&n, reference_child).is_ok());
+        },
+        NodeOrText::AppendText(t) => {
+            // FIXME(ajeffrey): convert directly from tendrils to DOMStrings
+            let s: String = t.into();
+            let text = Text::new(DOMString::from(s), &parent.owner_doc());
+            assert!(parent.InsertBefore(text.upcast(), reference_child).is_ok());
+        }
+    }
+}
+
+impl<'a> TreeSink for Sink {
+    type Output = Self;
+    fn finish(self) -> Self { self }
+
+    type Handle = JS<Node>;
+
+    fn get_document(&mut self) -> JS<Node> {
+        JS::from_ref(self.document.upcast())
+    }
+
+    fn get_template_contents(&self, target: JS<Node>) -> JS<Node> {
+        let template = target.downcast::<HTMLTemplateElement>()
+            .expect("tried to get template contents of non-HTMLTemplateElement in HTML parsing");
+        JS::from_ref(template.Content().upcast())
+    }
+
+    fn same_node(&self, x: JS<Node>, y: JS<Node>) -> bool {
+        x == y
+    }
+
+    fn elem_name(&self, target: JS<Node>) -> QualName {
+        let elem = target.downcast::<Element>()
+            .expect("tried to get name of non-Element in HTML parsing");
+        QualName {
+            ns: elem.namespace().clone(),
+            local: elem.local_name().clone(),
+        }
+    }
+
+    fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>)
+            -> JS<Node> {
+        let elem = Element::create(name, None, &*self.document,
+                                   ElementCreator::ParserCreated);
+
+        for attr in attrs {
+            elem.set_attribute_from_parser(attr.name, DOMString::from(String::from(attr.value)), None);
+        }
+
+        JS::from_ref(elem.upcast())
+    }
+
+    fn create_comment(&mut self, text: StrTendril) -> JS<Node> {
+        let comment = Comment::new(DOMString::from(String::from(text)), &*self.document);
+        JS::from_ref(comment.upcast())
+    }
+
+    fn append_before_sibling(&mut self,
+            sibling: JS<Node>,
+            new_node: NodeOrText<JS<Node>>) -> Result<(), NodeOrText<JS<Node>>> {
+        // If there is no parent, return the node to the parser.
+        let parent = match sibling.GetParentNode() {
+            Some(p) => p,
+            None => return Err(new_node),
+        };
+
+        insert(&parent, Some(&*sibling), new_node);
+        Ok(())
+    }
+
+    fn parse_error(&mut self, msg: Cow<'static, str>) {
+        debug!("Parse error: {}", msg);
+    }
+
+    fn set_quirks_mode(&mut self, mode: QuirksMode) {
+        self.document.set_quirks_mode(mode);
+    }
+
+    fn append(&mut self, parent: JS<Node>, child: NodeOrText<JS<Node>>) {
+        // FIXME(#3701): Use a simpler algorithm and merge adjacent text nodes
+        insert(&parent, None, child);
+    }
+
+    fn append_doctype_to_document(&mut self, name: StrTendril, public_id: StrTendril,
+                                  system_id: StrTendril) {
+        let doc = &*self.document;
+        let doctype = DocumentType::new(
+            DOMString::from(String::from(name)), Some(DOMString::from(String::from(public_id))),
+            Some(DOMString::from(String::from(system_id))), doc);
+        doc.upcast::<Node>().AppendChild(doctype.upcast()).expect("Appending failed");
+    }
+
+    fn add_attrs_if_missing(&mut self, target: JS<Node>, attrs: Vec<Attribute>) {
+        let elem = target.downcast::<Element>()
+            .expect("tried to set attrs on non-Element in HTML parsing");
+        for attr in attrs {
+            elem.set_attribute_from_parser(attr.name, DOMString::from(String::from(attr.value)), None);
+        }
+    }
+
+    fn remove_from_parent(&mut self, target: JS<Node>) {
+        if let Some(ref parent) = target.GetParentNode() {
+            parent.RemoveChild(&*target).unwrap();
+        }
+    }
+
+    fn mark_script_already_started(&mut self, node: JS<Node>) {
+        let script = node.downcast::<HTMLScriptElement>();
+        script.map(|script| script.set_already_started(true));
+    }
+
+    fn complete_script(&mut self, node: JS<Node>) -> NextParserState {
+        let script = node.downcast::<HTMLScriptElement>();
+        if let Some(script) = script {
+            return script.prepare();
+        }
+        NextParserState::Continue
+    }
+
+    fn reparent_children(&mut self, node: JS<Node>, new_parent: JS<Node>) {
+        while let Some(ref child) = node.GetFirstChild() {
+            new_parent.AppendChild(child.r()).unwrap();
+        }
+
+    }
+}
+
+impl<'a> Serializable for &'a Node {
+    fn serialize<'wr, Wr: Write>(&self, serializer: &mut Serializer<'wr, Wr>,
+                                 traversal_scope: TraversalScope) -> io::Result<()> {
+        let node = *self;
+        match (traversal_scope, node.type_id()) {
+            (_, NodeTypeId::Element(..)) => {
+                let elem = node.downcast::<Element>().unwrap();
+                let name = QualName::new(elem.namespace().clone(),
+                                         elem.local_name().clone());
+                if traversal_scope == IncludeNode {
+                    let attrs = elem.attrs().iter().map(|attr| {
+                        let qname = QualName::new(attr.namespace().clone(),
+                                                  attr.local_name().clone());
+                        let value = attr.value().clone();
+                        (qname, value)
+                    }).collect::<Vec<_>>();
+                    let attr_refs = attrs.iter().map(|&(ref qname, ref value)| {
+                        let ar: AttrRef = (&qname, &**value);
+                        ar
+                    });
+                    try!(serializer.start_elem(name.clone(), attr_refs));
+                }
+
+                let children = if let Some(tpl) = node.downcast::<HTMLTemplateElement>() {
+                    // https://github.com/w3c/DOM-Parsing/issues/1
+                    tpl.Content().upcast::<Node>().children()
+                } else {
+                    node.children()
+                };
+
+                for handle in children {
+                    try!(handle.r().serialize(serializer, IncludeNode));
+                }
+
+                if traversal_scope == IncludeNode {
+                    try!(serializer.end_elem(name.clone()));
+                }
+                Ok(())
+            },
+
+            (ChildrenOnly, NodeTypeId::Document(_)) => {
+                for handle in node.children() {
+                    try!(handle.r().serialize(serializer, IncludeNode));
+                }
+                Ok(())
+            },
+
+            (ChildrenOnly, _) => Ok(()),
+
+            (IncludeNode, NodeTypeId::DocumentType) => {
+                let doctype = node.downcast::<DocumentType>().unwrap();
+                serializer.write_doctype(&doctype.name())
+            },
+
+            (IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::Text)) => {
+                let cdata = node.downcast::<CharacterData>().unwrap();
+                serializer.write_text(&cdata.data())
+            },
+
+            (IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::Comment)) => {
+                let cdata = node.downcast::<CharacterData>().unwrap();
+                serializer.write_comment(&cdata.data())
+            },
+
+            (IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction)) => {
+                let pi = node.downcast::<ProcessingInstruction>().unwrap();
+                let data = pi.upcast::<CharacterData>().data();
+                serializer.write_processing_instruction(&pi.target(), &data)
+            },
+
+            (IncludeNode, NodeTypeId::DocumentFragment) => Ok(()),
+
+            (IncludeNode, NodeTypeId::Document(_)) => panic!("Can't serialize Document node itself"),
+        }
+    }
+}
+
+/// FragmentContext is used only to pass this group of related values
+/// into functions.
+#[derive(Copy, Clone)]
+pub struct FragmentContext<'a> {
+    pub context_elem: &'a Node,
+    pub form_elem: Option<&'a Node>,
+}
+
+pub enum ParseContext<'a> {
+    Fragment(FragmentContext<'a>),
+    Owner(Option<PipelineId>),
+}
+
+pub fn parse_html(document: &Document,
+                  input: DOMString,
+                  url: Url,
+                  context: ParseContext) {
+    let sink = Sink {
+        base_url: url,
+        document: JS::from_ref(document),
+    };
+
+    let options = TreeBuilderOpts {
+        ignore_missing_rules: true,
+        .. Default::default()
+    };
+
+    let parser = match context {
+        ParseContext::Owner(owner) => {
+            let tb = TreeBuilder::new(sink, options);
+            let tok = HtmlTokenizer::new(tb, Default::default());
+
+            ServoParser::new(
+                document, owner, Tokenizer::HTML(tok), LastChunkState::NotReceived)
+        },
+        ParseContext::Fragment(fc) => {
+            let tb = TreeBuilder::new_for_fragment(
+                sink,
+                JS::from_ref(fc.context_elem),
+                fc.form_elem.map(|n| JS::from_ref(n)),
+                options);
+
+            let tok_options = TokenizerOpts {
+                initial_state: Some(tb.tokenizer_state_for_context_elem()),
+                .. Default::default()
+            };
+            let tok = HtmlTokenizer::new(tb, tok_options);
+
+            ServoParser::new(
+                document, None, Tokenizer::HTML(tok), LastChunkState::Received)
+        }
+    };
+    parser.parse_chunk(String::from(input));
+}
+
+// https://html.spec.whatwg.org/multipage/#parsing-html-fragments
+pub fn parse_html_fragment(context_node: &Node,
+                           input: DOMString,
+                           output: &Node) {
+    let window = window_from_node(context_node);
+    let context_document = document_from_node(context_node);
+    let context_document = context_document.r();
+    let url = context_document.url();
+
+    // Step 1.
+    let loader = DocumentLoader::new(&*context_document.loader());
+    let document = Document::new(window.r(), None, Some(url.clone()),
+                                 IsHTMLDocument::HTMLDocument,
+                                 None, None,
+                                 DocumentSource::FromParser,
+                                 loader,
+                                 None, None);
+
+    // Step 2.
+    document.set_quirks_mode(context_document.quirks_mode());
+
+    // Step 11.
+    let form = context_node.inclusive_ancestors()
+                           .find(|element| element.is::<HTMLFormElement>());
+    let fragment_context = FragmentContext {
+        context_elem: context_node,
+        form_elem: form.r(),
+    };
+    parse_html(document.r(), input, url.clone(), ParseContext::Fragment(fragment_context));
+
+    // Step 14.
+    let root_element = document.GetDocumentElement().expect("no document element");
+    for child in root_element.upcast::<Node>().children() {
+        output.AppendChild(child.r()).unwrap();
+    }
+}

components/script/dom/servoparser/mod.rs

@@ -0,0 +1,452 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use document_loader::LoadType;
+use dom::bindings::cell::DOMRefCell;
+use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
+use dom::bindings::codegen::Bindings::HTMLImageElementBinding::HTMLImageElementMethods;
+use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
+use dom::bindings::codegen::Bindings::ServoParserBinding;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::js::{JS, Root};
+use dom::bindings::refcounted::Trusted;
+use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::str::DOMString;
+use dom::bindings::trace::JSTraceable;
+use dom::document::Document;
+use dom::globalscope::GlobalScope;
+use dom::htmlimageelement::HTMLImageElement;
+use dom::node::Node;
+use encoding::all::UTF_8;
+use encoding::types::{DecoderTrap, Encoding};
+use html5ever::tokenizer::Tokenizer as HtmlTokenizer;
+use html5ever::tree_builder::Tracer as HtmlTracer;
+use html5ever::tree_builder::TreeBuilder as HtmlTreeBuilder;
+use hyper::header::ContentType;
+use hyper::mime::{Mime, SubLevel, TopLevel};
+use hyper_serde::Serde;
+use js::jsapi::JSTracer;
+use msg::constellation_msg::PipelineId;
+use net_traits::{AsyncResponseListener, Metadata, NetworkError};
+use network_listener::PreInvoke;
+use profile_traits::time::{TimerMetadata, TimerMetadataFrameType};
+use profile_traits::time::{TimerMetadataReflowType, ProfilerCategory, profile};
+use script_thread::ScriptThread;
+use std::cell::Cell;
+use url::Url;
+use util::resource_files::read_resource_file;
+use xml5ever::tokenizer::XmlTokenizer;
+use xml5ever::tree_builder::{Tracer as XmlTracer, XmlTreeBuilder};
+
+pub mod html;
+pub mod xml;
+
+#[dom_struct]
+pub struct ServoParser {
+    reflector: Reflector,
+    /// The document associated with this parser.
+    document: JS<Document>,
+    /// The pipeline associated with this parse, unavailable if this parse
+    /// does not correspond to a page load.
+    pipeline: Option<PipelineId>,
+    /// Input chunks received but not yet passed to the parser.
+    pending_input: DOMRefCell<Vec<String>>,
+    /// The tokenizer of this parser.
+    tokenizer: DOMRefCell<Tokenizer>,
+    /// Whether to expect any further input from the associated network request.
+    last_chunk_received: Cell<bool>,
+    /// Whether this parser should avoid passing any further data to the tokenizer.
+    suspended: Cell<bool>,
+}
+
+#[derive(PartialEq)]
+enum LastChunkState {
+    Received,
+    NotReceived,
+}
+
+impl ServoParser {
+    #[allow(unrooted_must_root)]
+    fn new_inherited(
+            document: &Document,
+            pipeline: Option<PipelineId>,
+            tokenizer: Tokenizer,
+            last_chunk_state: LastChunkState)
+            -> Self {
+        ServoParser {
+            reflector: Reflector::new(),
+            document: JS::from_ref(document),
+            pipeline: pipeline,
+            pending_input: DOMRefCell::new(vec![]),
+            tokenizer: DOMRefCell::new(tokenizer),
+            last_chunk_received: Cell::new(last_chunk_state == LastChunkState::Received),
+            suspended: Default::default(),
+        }
+    }
+
+    #[allow(unrooted_must_root)]
+    fn new(
+            document: &Document,
+            pipeline: Option<PipelineId>,
+            tokenizer: Tokenizer,
+            last_chunk_state: LastChunkState)
+            -> Root<Self> {
+        reflect_dom_object(
+            box ServoParser::new_inherited(document, pipeline, tokenizer, last_chunk_state),
+            document.window(),
+            ServoParserBinding::Wrap)
+    }
+
+    pub fn document(&self) -> &Document {
+        &self.document
+    }
+
+    pub fn pipeline(&self) -> Option<PipelineId> {
+        self.pipeline
+    }
+
+    fn has_pending_input(&self) -> bool {
+        !self.pending_input.borrow().is_empty()
+    }
+
+    fn push_input_chunk(&self, chunk: String) {
+        self.pending_input.borrow_mut().push(chunk);
+    }
+
+    fn take_next_input_chunk(&self) -> Option<String> {
+        let mut pending_input = self.pending_input.borrow_mut();
+        if pending_input.is_empty() {
+            None
+        } else {
+            Some(pending_input.remove(0))
+        }
+    }
+
+    fn last_chunk_received(&self) -> bool {
+        self.last_chunk_received.get()
+    }
+
+    fn mark_last_chunk_received(&self) {
+        self.last_chunk_received.set(true)
+    }
+
+    fn set_plaintext_state(&self) {
+        self.tokenizer.borrow_mut().set_plaintext_state()
+    }
+
+    pub fn end_tokenizer(&self) {
+        self.tokenizer.borrow_mut().end()
+    }
+
+    pub fn suspend(&self) {
+        assert!(!self.suspended.get());
+        self.suspended.set(true);
+    }
+
+    pub fn resume(&self) {
+        assert!(self.suspended.get());
+        self.suspended.set(false);
+        self.parse_sync();
+    }
+
+    pub fn is_suspended(&self) -> bool {
+        self.suspended.get()
+    }
+
+    fn parse_sync(&self) {
+        let metadata = TimerMetadata {
+            url: self.document().url().as_str().into(),
+            iframe: TimerMetadataFrameType::RootWindow,
+            incremental: TimerMetadataReflowType::FirstReflow,
+        };
+        let profiler_category = self.tokenizer.borrow().profiler_category();
+        profile(profiler_category,
+                Some(metadata),
+                self.document().window().upcast::<GlobalScope>().time_profiler_chan().clone(),
+                || self.do_parse_sync())
+    }
+
+    fn do_parse_sync(&self) {
+        // This parser will continue to parse while there is either pending input or
+        // the parser remains unsuspended.
+        loop {
+            self.document().reflow_if_reflow_timer_expired();
+            if let Some(chunk) = self.take_next_input_chunk() {
+                self.tokenizer.borrow_mut().feed(chunk);
+            } else {
+                self.tokenizer.borrow_mut().run();
+            }
+
+            // Document parsing is blocked on an external resource.
+            if self.suspended.get() {
+                return;
+            }
+
+            if !self.has_pending_input() {
+                break;
+            }
+        }
+
+        if self.last_chunk_received() {
+            self.finish();
+        }
+    }
+
+    fn parse_chunk(&self, input: String) {
+        self.document().set_current_parser(Some(self));
+        self.push_input_chunk(input);
+        if !self.is_suspended() {
+            self.parse_sync();
+        }
+    }
+
+    fn finish(&self) {
+        assert!(!self.suspended.get());
+        assert!(!self.has_pending_input());
+
+        self.tokenizer.borrow_mut().end();
+        debug!("finished parsing");
+
+        self.document().set_current_parser(None);
+
+        if let Some(pipeline) = self.pipeline() {
+            ScriptThread::parsing_complete(pipeline);
+        }
+    }
+}
+
+#[derive(HeapSizeOf)]
+#[must_root]
+enum Tokenizer {
+    HTML(
+        #[ignore_heap_size_of = "Defined in html5ever"]
+        HtmlTokenizer<HtmlTreeBuilder<JS<Node>, Sink>>
+    ),
+    XML(
+        #[ignore_heap_size_of = "Defined in xml5ever"]
+        XmlTokenizer<XmlTreeBuilder<JS<Node>, Sink>>
+    ),
+}
+
+#[derive(JSTraceable, HeapSizeOf)]
+#[must_root]
+struct Sink {
+    pub base_url: Url,
+    pub document: JS<Document>,
+}
+
+impl Tokenizer {
+    fn feed(&mut self, input: String) {
+        match *self {
+            Tokenizer::HTML(ref mut tokenizer) => tokenizer.feed(input.into()),
+            Tokenizer::XML(ref mut tokenizer) => tokenizer.feed(input.into()),
+        }
+    }
+
+    fn run(&mut self) {
+        match *self {
+            Tokenizer::HTML(ref mut tokenizer) => tokenizer.run(),
+            Tokenizer::XML(ref mut tokenizer) => tokenizer.run(),
+        }
+    }
+
+    fn end(&mut self) {
+        match *self {
+            Tokenizer::HTML(ref mut tokenizer) => tokenizer.end(),
+            Tokenizer::XML(ref mut tokenizer) => tokenizer.end(),
+        }
+    }
+
+    fn set_plaintext_state(&mut self) {
+        match *self {
+            Tokenizer::HTML(ref mut tokenizer) => tokenizer.set_plaintext_state(),
+            Tokenizer::XML(_) => { /* todo */ },
+        }
+    }
+
+    fn profiler_category(&self) -> ProfilerCategory {
+        match *self {
+            Tokenizer::HTML(_) => ProfilerCategory::ScriptParseHTML,
+            Tokenizer::XML(_) => ProfilerCategory::ScriptParseXML,
+        }
+    }
+}
+
+impl JSTraceable for Tokenizer {
+    fn trace(&self, trc: *mut JSTracer) {
+        struct Tracer(*mut JSTracer);
+        let tracer = Tracer(trc);
+
+        match *self {
+            Tokenizer::HTML(ref tokenizer) => {
+                impl HtmlTracer for Tracer {
+                    type Handle = JS<Node>;
+                    #[allow(unrooted_must_root)]
+                    fn trace_handle(&self, node: &JS<Node>) {
+                        node.trace(self.0);
+                    }
+                }
+                let tree_builder = tokenizer.sink();
+                tree_builder.trace_handles(&tracer);
+                tree_builder.sink().trace(trc);
+            },
+            Tokenizer::XML(ref tokenizer) => {
+                impl XmlTracer for Tracer {
+                    type Handle = JS<Node>;
+                    #[allow(unrooted_must_root)]
+                    fn trace_handle(&self, node: JS<Node>) {
+                        node.trace(self.0);
+                    }
+                }
+                let tree_builder = tokenizer.sink();
+                tree_builder.trace_handles(&tracer);
+                tree_builder.sink().trace(trc);
+            }
+        }
+    }
+}
+
+/// The context required for asynchronously fetching a document
+/// and parsing it progressively.
+pub struct ParserContext {
+    /// The parser that initiated the request.
+    parser: Option<Trusted<ServoParser>>,
+    /// Is this a synthesized document
+    is_synthesized_document: bool,
+    /// The pipeline associated with this document.
+    id: PipelineId,
+    /// The URL for this document.
+    url: Url,
+}
+
+impl ParserContext {
+    pub fn new(id: PipelineId, url: Url) -> ParserContext {
+        ParserContext {
+            parser: None,
+            is_synthesized_document: false,
+            id: id,
+            url: url,
+        }
+    }
+}
+
+impl AsyncResponseListener for ParserContext {
+    fn headers_available(&mut self, meta_result: Result<Metadata, NetworkError>) {
+        let mut ssl_error = None;
+        let metadata = match meta_result {
+            Ok(meta) => Some(meta),
+            Err(NetworkError::SslValidation(url, reason)) => {
+                ssl_error = Some(reason);
+                let mut meta = Metadata::default(url);
+                let mime: Option<Mime> = "text/html".parse().ok();
+                meta.set_content_type(mime.as_ref());
+                Some(meta)
+            },
+            Err(_) => None,
+        };
+        let content_type =
+            metadata.clone().and_then(|meta| meta.content_type).map(Serde::into_inner);
+        let parser = match ScriptThread::page_headers_available(&self.id,
+                                                                metadata) {
+            Some(parser) => parser,
+            None => return,
+        };
+
+        self.parser = Some(Trusted::new(&*parser));
+
+        match content_type {
+            Some(ContentType(Mime(TopLevel::Image, _, _))) => {
+                self.is_synthesized_document = true;
+                let page = "<html><body></body></html>".into();
+                parser.push_input_chunk(page);
+                parser.parse_sync();
+
+                let doc = parser.document();
+                let doc_body = Root::upcast::<Node>(doc.GetBody().unwrap());
+                let img = HTMLImageElement::new(atom!("img"), None, doc);
+                img.SetSrc(DOMString::from(self.url.to_string()));
+                doc_body.AppendChild(&Root::upcast::<Node>(img)).expect("Appending failed");
+
+            },
+            Some(ContentType(Mime(TopLevel::Text, SubLevel::Plain, _))) => {
+                // https://html.spec.whatwg.org/multipage/#read-text
+                let page = "<pre>\n".into();
+                parser.push_input_chunk(page);
+                parser.parse_sync();
+                parser.set_plaintext_state();
+            },
+            Some(ContentType(Mime(TopLevel::Text, SubLevel::Html, _))) => { // Handle text/html
+                if let Some(reason) = ssl_error {
+                    self.is_synthesized_document = true;
+                    let page_bytes = read_resource_file("badcert.html").unwrap();
+                    let page = String::from_utf8(page_bytes).unwrap();
+                    let page = page.replace("${reason}", &reason);
+                    parser.push_input_chunk(page);
+                    parser.parse_sync();
+                }
+            },
+            Some(ContentType(Mime(TopLevel::Text, SubLevel::Xml, _))) => {}, // Handle text/xml
+            Some(ContentType(Mime(toplevel, sublevel, _))) => {
+                if toplevel.as_str() == "application" && sublevel.as_str() == "xhtml+xml" {
+                    // Handle xhtml (application/xhtml+xml).
+                    return;
+                }
+
+                // Show warning page for unknown mime types.
+                let page = format!("<html><body><p>Unknown content type ({}/{}).</p></body></html>",
+                    toplevel.as_str(), sublevel.as_str());
+                self.is_synthesized_document = true;
+                parser.push_input_chunk(page);
+                parser.parse_sync();
+            },
+            None => {
+                // No content-type header.
+                // Merge with #4212 when fixed.
+            }
+        }
+    }
+
+    fn data_available(&mut self, payload: Vec<u8>) {
+        if !self.is_synthesized_document {
+            // FIXME: use Vec<u8> (html5ever #34)
+            let data = UTF_8.decode(&payload, DecoderTrap::Replace).unwrap();
+            let parser = match self.parser.as_ref() {
+                Some(parser) => parser.root(),
+                None => return,
+            };
+            parser.parse_chunk(data);
+        }
+    }
+
+    fn response_complete(&mut self, status: Result<(), NetworkError>) {
+        let parser = match self.parser.as_ref() {
+            Some(parser) => parser.root(),
+            None => return,
+        };
+
+        if let Err(NetworkError::Internal(ref reason)) = status {
+            // Show an error page for network errors,
+            // certificate errors are handled earlier.
+            self.is_synthesized_document = true;
+            let page_bytes = read_resource_file("neterror.html").unwrap();
+            let page = String::from_utf8(page_bytes).unwrap();
+            let page = page.replace("${reason}", reason);
+            parser.push_input_chunk(page);
+            parser.parse_sync();
+        } else if let Err(err) = status {
+            // TODO(Savago): we should send a notification to callers #5463.
+            debug!("Failed to load page URL {}, error: {:?}", self.url, err);
+        }
+
+        parser.document()
+            .finish_load(LoadType::PageSource(self.url.clone()));
+
+        parser.mark_last_chunk_received();
+        if !parser.is_suspended() {
+            parser.parse_sync();
+        }
+    }
+}
+
+impl PreInvoke for ParserContext {}

components/script/dom/servoparser/xml.rs

@@ -0,0 +1,147 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#![allow(unrooted_must_root)]
+
+use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::js::{JS, Root};
+use dom::bindings::str::DOMString;
+use dom::comment::Comment;
+use dom::document::Document;
+use dom::documenttype::DocumentType;
+use dom::element::{Element, ElementCreator};
+use dom::htmlscriptelement::HTMLScriptElement;
+use dom::node::Node;
+use dom::processinginstruction::ProcessingInstruction;
+use dom::text::Text;
+use html5ever;
+use msg::constellation_msg::PipelineId;
+use std::borrow::Cow;
+use string_cache::{Atom, QualName, Namespace};
+use super::{LastChunkState, ServoParser, Sink, Tokenizer};
+use url::Url;
+use xml5ever::tendril::StrTendril;
+use xml5ever::tokenizer::{Attribute, QName, XmlTokenizer};
+use xml5ever::tree_builder::{NextParserState, NodeOrText, TreeSink, XmlTreeBuilder};
+
+impl<'a> TreeSink for Sink {
+    type Handle = JS<Node>;
+
+    fn parse_error(&mut self, msg: Cow<'static, str>) {
+        debug!("Parse error: {}", msg);
+    }
+
+    fn get_document(&mut self) -> JS<Node> {
+        JS::from_ref(self.document.upcast())
+    }
+
+    fn elem_name(&self, target: &JS<Node>) -> QName {
+        let elem = target.downcast::<Element>()
+            .expect("tried to get name of non-Element in XML parsing");
+        QName {
+            prefix: elem.prefix().as_ref().map_or(atom!(""), |p| Atom::from(&**p)),
+            namespace_url: elem.namespace().0.clone(),
+            local: elem.local_name().clone(),
+        }
+    }
+
+    fn create_element(&mut self, name: QName, attrs: Vec<Attribute>)
+            -> JS<Node> {
+        let prefix = if name.prefix == atom!("") { None } else { Some(name.prefix) };
+        let name = QualName {
+            ns: Namespace(name.namespace_url),
+            local: name.local,
+        };
+        let elem = Element::create(name, prefix, &*self.document,
+                                   ElementCreator::ParserCreated);
+
+        for attr in attrs {
+            let name = QualName {
+                ns: Namespace(attr.name.namespace_url),
+                local: attr.name.local,
+            };
+            elem.set_attribute_from_parser(name, DOMString::from(String::from(attr.value)), None);
+        }
+
+        JS::from_ref(elem.upcast())
+    }
+
+    fn create_comment(&mut self, text: StrTendril) -> JS<Node> {
+        let comment = Comment::new(DOMString::from(String::from(text)), &*self.document);
+        JS::from_ref(comment.upcast())
+    }
+
+    fn append(&mut self, parent: JS<Node>, child: NodeOrText<JS<Node>>) {
+        let child = match child {
+            NodeOrText::AppendNode(n) => Root::from_ref(&*n),
+            NodeOrText::AppendText(t) => {
+                let s: String = t.into();
+                let text = Text::new(DOMString::from(s), &self.document);
+                Root::upcast(text)
+            }
+        };
+        assert!(parent.AppendChild(child.r()).is_ok());
+    }
+
+    fn append_doctype_to_document(&mut self, name: StrTendril, public_id: StrTendril,
+                                  system_id: StrTendril) {
+        let doc = &*self.document;
+        let doctype = DocumentType::new(
+            DOMString::from(String::from(name)), Some(DOMString::from(String::from(public_id))),
+            Some(DOMString::from(String::from(system_id))), doc);
+        doc.upcast::<Node>().AppendChild(doctype.upcast()).expect("Appending failed");
+    }
+
+    fn create_pi(&mut self, target: StrTendril,  data: StrTendril) -> JS<Node> {
+        let doc = &*self.document;
+        let pi = ProcessingInstruction::new(
+            DOMString::from(String::from(target)), DOMString::from(String::from(data)),
+            doc);
+        JS::from_ref(pi.upcast())
+    }
+
+    fn mark_script_already_started(&mut self, node: Self::Handle) {
+        let script = node.downcast::<HTMLScriptElement>();
+        if let Some(script) = script {
+            script.set_already_started(true);
+        }
+    }
+
+    fn complete_script(&mut self, node: Self::Handle) -> NextParserState {
+        let script = node.downcast::<HTMLScriptElement>();
+        if let Some(script) = script {
+            return match script.prepare() {
+                html5ever::tree_builder::NextParserState::Continue => NextParserState::Continue,
+                html5ever::tree_builder::NextParserState::Suspend => NextParserState::Suspend
+            };
+        }
+        NextParserState::Continue
+    }
+}
+
+
+pub enum ParseContext {
+    Owner(Option<PipelineId>)
+}
+
+
+pub fn parse_xml(document: &Document,
+                 input: DOMString,
+                 url: Url,
+                 context: ParseContext) {
+    let parser = match context {
+        ParseContext::Owner(owner) => {
+            let tb = XmlTreeBuilder::new(Sink {
+                base_url: url,
+                document: JS::from_ref(document),
+            });
+            let tok = XmlTokenizer::new(tb, Default::default());
+
+            ServoParser::new(
+                document, owner, Tokenizer::XML(tok), LastChunkState::NotReceived)
+        }
+    };
+    parser.parse_chunk(String::from(input));
+}