diff options
Diffstat (limited to 'components/script/dom/servoparser/html.rs')
| -rw-r--r-- | components/script/dom/servoparser/html.rs | 430 |
1 files changed, 165 insertions, 265 deletions
diff --git a/components/script/dom/servoparser/html.rs b/components/script/dom/servoparser/html.rs index 6142dba20f6..1bbc0aeeae8 100644 --- a/components/script/dom/servoparser/html.rs +++ b/components/script/dom/servoparser/html.rs @@ -1,77 +1,72 @@ /* 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/. */ + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ #![allow(unrooted_must_root)] -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, Root}; -use dom::bindings::str::DOMString; -use dom::bindings::trace::JSTraceable; -use dom::characterdata::CharacterData; -use dom::comment::Comment; -use dom::document::Document; -use dom::documenttype::DocumentType; -use dom::element::{Element, ElementCreator}; -use dom::htmlformelement::{FormControlElementHelpers, HTMLFormElement}; -use dom::htmlscriptelement::HTMLScriptElement; -use dom::htmltemplateelement::HTMLTemplateElement; -use dom::node::Node; -use dom::processinginstruction::ProcessingInstruction; -use dom::virtualmethods::vtable_for; -use html5ever::Attribute; -use html5ever::QualName; -use html5ever::serialize::{AttrRef, Serializable, Serializer}; +use crate::dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods; +use crate::dom::bindings::inheritance::{Castable, CharacterDataTypeId, NodeTypeId}; +use crate::dom::bindings::root::{Dom, DomRoot}; +use crate::dom::bindings::trace::JSTraceable; +use crate::dom::characterdata::CharacterData; +use crate::dom::document::Document; +use crate::dom::documentfragment::DocumentFragment; +use crate::dom::documenttype::DocumentType; +use crate::dom::element::Element; +use crate::dom::htmlscriptelement::HTMLScriptElement; +use crate::dom::htmltemplateelement::HTMLTemplateElement; +use crate::dom::node::Node; +use crate::dom::processinginstruction::ProcessingInstruction; +use crate::dom::servoparser::{ParsingAlgorithm, Sink}; +use html5ever::buffer_queue::BufferQueue; use html5ever::serialize::TraversalScope; -use html5ever::serialize::TraversalScope::{ChildrenOnly, IncludeNode}; -use html5ever::tendril::StrTendril; +use html5ever::serialize::TraversalScope::IncludeNode; +use html5ever::serialize::{AttrRef, Serialize, Serializer}; use html5ever::tokenizer::{Tokenizer as HtmlTokenizer, TokenizerOpts, TokenizerResult}; -use html5ever::tokenizer::buffer_queue::BufferQueue; -use html5ever::tree_builder::{NodeOrText, QuirksMode}; -use html5ever::tree_builder::{Tracer as HtmlTracer, TreeBuilder, TreeBuilderOpts, TreeSink}; +use html5ever::tree_builder::{Tracer as HtmlTracer, TreeBuilder, TreeBuilderOpts}; +use html5ever::QualName; use js::jsapi::JSTracer; use servo_url::ServoUrl; -use std::ascii::AsciiExt; -use std::borrow::Cow; -use std::io::{self, Write}; -use style::context::QuirksMode as ServoQuirksMode; +use std::io; -#[derive(HeapSizeOf, JSTraceable)] -#[must_root] +#[derive(JSTraceable, MallocSizeOf)] +#[unrooted_must_root_lint::must_root] pub struct Tokenizer { - #[ignore_heap_size_of = "Defined in html5ever"] - inner: HtmlTokenizer<TreeBuilder<JS<Node>, Sink>>, + #[ignore_malloc_size_of = "Defined in html5ever"] + inner: HtmlTokenizer<TreeBuilder<Dom<Node>, Sink>>, } impl Tokenizer { pub fn new( - document: &Document, - url: ServoUrl, - fragment_context: Option<super::FragmentContext>) - -> Self { + document: &Document, + url: ServoUrl, + fragment_context: Option<super::FragmentContext>, + parsing_algorithm: ParsingAlgorithm, + ) -> Self { let sink = Sink { base_url: url, - document: JS::from_ref(document), + document: Dom::from_ref(document), current_line: 1, + script: Default::default(), + parsing_algorithm: parsing_algorithm, }; let options = TreeBuilderOpts { ignore_missing_rules: true, - .. Default::default() + ..Default::default() }; let inner = if let Some(fc) = fragment_context { let tb = TreeBuilder::new_for_fragment( sink, - JS::from_ref(fc.context_elem), - fc.form_elem.map(|n| JS::from_ref(n)), - options); + Dom::from_ref(fc.context_elem), + fc.form_elem.map(|n| Dom::from_ref(n)), + options, + ); let tok_options = TokenizerOpts { initial_state: Some(tb.tokenizer_state_for_context_elem()), - .. Default::default() + ..Default::default() }; HtmlTokenizer::new(tb, tok_options) @@ -79,15 +74,13 @@ impl Tokenizer { HtmlTokenizer::new(TreeBuilder::new(sink, options), Default::default()) }; - Tokenizer { - inner: inner, - } + Tokenizer { inner: inner } } - pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), Root<HTMLScriptElement>> { + pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), DomRoot<HTMLScriptElement>> { match self.inner.feed(input) { TokenizerResult::Done => Ok(()), - TokenizerResult::Script(script) => Err(Root::from_ref(script.downcast().unwrap())), + TokenizerResult::Script(script) => Err(DomRoot::from_ref(script.downcast().unwrap())), } } @@ -96,7 +89,7 @@ impl Tokenizer { } pub fn url(&self) -> &ServoUrl { - &self.inner.sink().sink().base_url + &self.inner.sink.sink.base_url } pub fn set_plaintext_state(&mut self) { @@ -105,259 +98,166 @@ impl Tokenizer { } #[allow(unsafe_code)] -unsafe impl JSTraceable for HtmlTokenizer<TreeBuilder<JS<Node>, Sink>> { +unsafe impl JSTraceable for HtmlTokenizer<TreeBuilder<Dom<Node>, Sink>> { unsafe fn trace(&self, trc: *mut JSTracer) { struct Tracer(*mut JSTracer); let tracer = Tracer(trc); impl HtmlTracer for Tracer { - type Handle = JS<Node>; + type Handle = Dom<Node>; #[allow(unrooted_must_root)] - fn trace_handle(&self, node: &JS<Node>) { - unsafe { node.trace(self.0); } + fn trace_handle(&self, node: &Dom<Node>) { + unsafe { + node.trace(self.0); + } } } - let tree_builder = self.sink(); + let tree_builder = &self.sink; tree_builder.trace_handles(&tracer); - tree_builder.sink().trace(trc); + tree_builder.sink.trace(trc); } } -#[derive(JSTraceable, HeapSizeOf)] -#[must_root] -struct Sink { - base_url: ServoUrl, - document: JS<Document>, - current_line: u64, +fn start_element<S: Serializer>(node: &Element, serializer: &mut S) -> io::Result<()> { + let name = QualName::new(None, node.namespace().clone(), node.local_name().clone()); + let attrs = node + .attrs() + .iter() + .map(|attr| { + let qname = QualName::new(None, 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 + }); + serializer.start_elem(name, attr_refs)?; + Ok(()) } -impl 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(&mut 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 same_tree(&self, x: JS<Node>, y: JS<Node>) -> bool { - let x = x.downcast::<Element>().expect("Element node expected"); - let y = y.downcast::<Element>().expect("Element node expected"); - - x.is_in_same_home_subtree(y) - } - - fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>) - -> JS<Node> { - let elem = Element::create(name, None, &*self.document, - ElementCreator::ParserCreated(self.current_line)); +fn end_element<S: Serializer>(node: &Element, serializer: &mut S) -> io::Result<()> { + let name = QualName::new(None, node.namespace().clone(), node.local_name().clone()); + serializer.end_elem(name) +} - for attr in attrs { - elem.set_attribute_from_parser(attr.name, DOMString::from(String::from(attr.value)), None); - } +enum SerializationCommand { + OpenElement(DomRoot<Element>), + CloseElement(DomRoot<Element>), + SerializeNonelement(DomRoot<Node>), +} - JS::from_ref(elem.upcast()) - } +struct SerializationIterator { + stack: Vec<SerializationCommand>, +} - 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 rev_children_iter(n: &Node) -> impl Iterator<Item = DomRoot<Node>> { + if n.downcast::<Element>().map_or(false, |e| e.is_void()) { + return Node::new_document_node().rev_children(); } - fn has_parent_node(&self, node: JS<Node>) -> bool { - node.GetParentNode().is_some() + match n.downcast::<HTMLTemplateElement>() { + Some(t) => t.Content().upcast::<Node>().rev_children(), + None => n.rev_children(), } +} - fn associate_with_form(&mut self, target: JS<Node>, form: JS<Node>) { - let node = target; - let form = Root::downcast::<HTMLFormElement>(Root::from_ref(&*form)) - .expect("Owner must be a form element"); - - let elem = node.downcast::<Element>(); - let control = elem.as_ref().and_then(|e| e.as_maybe_form_control()); - - if let Some(control) = control { - control.set_form_owner_from_parser(&form); +impl SerializationIterator { + fn new(node: &Node, skip_first: bool) -> SerializationIterator { + let mut ret = SerializationIterator { stack: vec![] }; + if skip_first || node.is::<DocumentFragment>() || node.is::<Document>() { + for c in rev_children_iter(node) { + ret.push_node(&*c); + } } else { - // TODO remove this code when keygen is implemented. - assert!(node.NodeName() == "KEYGEN", "Unknown form-associatable element"); + ret.push_node(node); } + ret } - fn append_before_sibling(&mut self, - sibling: JS<Node>, - new_node: NodeOrText<JS<Node>>) { - let parent = sibling.GetParentNode() - .expect("append_before_sibling called on node without parent"); - - super::insert(&parent, Some(&*sibling), new_node); - } - - fn parse_error(&mut self, msg: Cow<'static, str>) { - debug!("Parse error: {}", msg); - } - - fn set_quirks_mode(&mut self, mode: QuirksMode) { - let mode = match mode { - QuirksMode::Quirks => ServoQuirksMode::Quirks, - QuirksMode::LimitedQuirks => ServoQuirksMode::LimitedQuirks, - QuirksMode::NoQuirks => ServoQuirksMode::NoQuirks, - }; - self.document.set_quirks_mode(mode); - } - - fn append(&mut self, parent: JS<Node>, child: NodeOrText<JS<Node>>) { - super::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 push_node(&mut self, n: &Node) { + match n.downcast::<Element>() { + Some(e) => self + .stack + .push(SerializationCommand::OpenElement(DomRoot::from_ref(e))), + None => self.stack.push(SerializationCommand::SerializeNonelement( + DomRoot::from_ref(n), + )), } } +} - fn remove_from_parent(&mut self, target: JS<Node>) { - if let Some(ref parent) = target.GetParentNode() { - parent.RemoveChild(&*target).unwrap(); - } - } +impl Iterator for SerializationIterator { + type Item = SerializationCommand; - fn mark_script_already_started(&mut self, node: JS<Node>) { - let script = node.downcast::<HTMLScriptElement>(); - script.map(|script| script.set_already_started(true)); - } + fn next(&mut self) -> Option<SerializationCommand> { + let res = self.stack.pop(); - fn reparent_children(&mut self, node: JS<Node>, new_parent: JS<Node>) { - while let Some(ref child) = node.GetFirstChild() { - new_parent.AppendChild(&child).unwrap(); + if let Some(SerializationCommand::OpenElement(ref e)) = res { + self.stack + .push(SerializationCommand::CloseElement(e.clone())); + for c in rev_children_iter(&*e.upcast::<Node>()) { + self.push_node(&c); + } } - } - - /// https://html.spec.whatwg.org/multipage/#html-integration-point - /// Specifically, the <annotation-xml> cases. - fn is_mathml_annotation_xml_integration_point(&self, handle: JS<Node>) -> bool { - let elem = handle.downcast::<Element>().unwrap(); - elem.get_attribute(&ns!(), &local_name!("encoding")).map_or(false, |attr| { - attr.value().eq_ignore_ascii_case("text/html") - || attr.value().eq_ignore_ascii_case("application/xhtml+xml") - }) - } - - fn set_current_line(&mut self, line_number: u64) { - self.current_line = line_number; - } - fn pop(&mut self, node: JS<Node>) { - let node = Root::from_ref(&*node); - vtable_for(&node).pop(); + res } } -impl<'a> Serializable for &'a Node { - fn serialize<'wr, Wr: Write>(&self, serializer: &mut Serializer<'wr, Wr>, - traversal_scope: TraversalScope) -> io::Result<()> { +impl<'a> Serialize for &'a Node { + fn serialize<S: Serializer>( + &self, + serializer: &mut S, + 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).serialize(serializer, IncludeNode)); - } - - if traversal_scope == IncludeNode { - try!(serializer.end_elem(name.clone())); - } - Ok(()) - }, - - (ChildrenOnly, NodeTypeId::Document(_)) => { - for handle in node.children() { - try!((&*handle).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"), + let iter = SerializationIterator::new(node, traversal_scope != IncludeNode); + + for cmd in iter { + match cmd { + SerializationCommand::OpenElement(n) => { + start_element(&n, serializer)?; + }, + + SerializationCommand::CloseElement(n) => { + end_element(&&n, serializer)?; + }, + + SerializationCommand::SerializeNonelement(n) => match n.type_id() { + NodeTypeId::DocumentType => { + let doctype = n.downcast::<DocumentType>().unwrap(); + serializer.write_doctype(&doctype.name())?; + }, + + NodeTypeId::CharacterData(CharacterDataTypeId::Text(_)) => { + let cdata = n.downcast::<CharacterData>().unwrap(); + serializer.write_text(&cdata.data())?; + }, + + NodeTypeId::CharacterData(CharacterDataTypeId::Comment) => { + let cdata = n.downcast::<CharacterData>().unwrap(); + serializer.write_comment(&cdata.data())?; + }, + + NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction) => { + let pi = n.downcast::<ProcessingInstruction>().unwrap(); + let data = pi.upcast::<CharacterData>().data(); + serializer.write_processing_instruction(&pi.target(), &data)?; + }, + + NodeTypeId::DocumentFragment(_) => {}, + + NodeTypeId::Document(_) => panic!("Can't serialize Document node itself"), + NodeTypeId::Element(_) => panic!("Element shouldn't appear here"), + NodeTypeId::Attr => panic!("Attr shouldn't appear here"), + }, + } } + + Ok(()) } } |