mirror of
https://github.com/servo/servo.git
synced 2025-08-02 20:20:14 +01:00
Auto merge of #13675 - nox:servoparser, r=Ms2ger
Clean up the parsers into a single interface <!-- Reviewable:start --> This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/13675) <!-- Reviewable:end -->
This commit is contained in:
commit
928e5ad1e5
17 changed files with 368 additions and 688 deletions
|
@ -2748,7 +2748,8 @@ assert!((*cache)[PrototypeList::Constructor::%(id)s as usize].is_null());
|
|||
interface.get());
|
||||
""" % {"id": name, "name": str_to_const_array(name)})
|
||||
|
||||
if len(self.descriptor.prototypeChain) == 1:
|
||||
parentName = self.descriptor.getParentName()
|
||||
if not parentName:
|
||||
if self.descriptor.interface.getExtendedAttribute("ExceptionClass"):
|
||||
getPrototypeProto = "prototype_proto.set(JS_GetErrorPrototype(cx))"
|
||||
elif self.descriptor.interface.isIteratorInterface():
|
||||
|
@ -2757,7 +2758,7 @@ assert!((*cache)[PrototypeList::Constructor::%(id)s as usize].is_null());
|
|||
getPrototypeProto = "prototype_proto.set(JS_GetObjectPrototype(cx, global))"
|
||||
else:
|
||||
getPrototypeProto = ("%s::GetProtoObject(cx, global, prototype_proto.handle_mut())" %
|
||||
toBindingNamespace(self.descriptor.getParentName()))
|
||||
toBindingNamespace(parentName))
|
||||
|
||||
code = [CGGeneric("""\
|
||||
rooted!(in(cx) let mut prototype_proto = ptr::null_mut());
|
||||
|
|
|
@ -76,6 +76,7 @@ use dom::popstateevent::PopStateEvent;
|
|||
use dom::processinginstruction::ProcessingInstruction;
|
||||
use dom::progressevent::ProgressEvent;
|
||||
use dom::range::Range;
|
||||
use dom::servoparser::ServoParser;
|
||||
use dom::storageevent::StorageEvent;
|
||||
use dom::stylesheetlist::StyleSheetList;
|
||||
use dom::text::Text;
|
||||
|
@ -103,7 +104,6 @@ use net_traits::request::RequestInit;
|
|||
use net_traits::response::HttpsState;
|
||||
use num_traits::ToPrimitive;
|
||||
use origin::Origin;
|
||||
use parse::{MutNullableParserField, ParserRef, ParserRoot};
|
||||
use script_layout_interface::message::{Msg, ReflowQueryType};
|
||||
use script_thread::{MainThreadScriptMsg, Runnable};
|
||||
use script_traits::{AnimationState, CompositorEvent, MouseButton, MouseEventType, MozBrowserEvent};
|
||||
|
@ -226,7 +226,7 @@ pub struct Document {
|
|||
/// Tracks all outstanding loads related to this document.
|
||||
loader: DOMRefCell<DocumentLoader>,
|
||||
/// The current active HTML parser, to allow resuming after interruptions.
|
||||
current_parser: MutNullableParserField,
|
||||
current_parser: MutNullableHeap<JS<ServoParser>>,
|
||||
/// When we should kick off a reflow. This happens during parsing.
|
||||
reflow_timeout: Cell<Option<u64>>,
|
||||
/// The cached first `base` element with an `href` attribute.
|
||||
|
@ -1627,11 +1627,11 @@ impl Document {
|
|||
global_scope.constellation_chan().send(load_event).unwrap();
|
||||
}
|
||||
|
||||
pub fn set_current_parser(&self, script: Option<ParserRef>) {
|
||||
pub fn set_current_parser(&self, script: Option<&ServoParser>) {
|
||||
self.current_parser.set(script);
|
||||
}
|
||||
|
||||
pub fn get_current_parser(&self) -> Option<ParserRoot> {
|
||||
pub fn get_current_parser(&self) -> Option<Root<ServoParser>> {
|
||||
self.current_parser.get()
|
||||
}
|
||||
|
||||
|
|
|
@ -18,9 +18,9 @@ use dom::bindings::str::DOMString;
|
|||
use dom::document::{Document, IsHTMLDocument};
|
||||
use dom::document::DocumentSource;
|
||||
use dom::globalscope::GlobalScope;
|
||||
use dom::servoparser::html::{ParseContext, parse_html};
|
||||
use dom::servoparser::xml::{self, parse_xml};
|
||||
use dom::window::Window;
|
||||
use parse::html::{ParseContext, parse_html};
|
||||
use parse::xml::{self, parse_xml};
|
||||
|
||||
#[dom_struct]
|
||||
pub struct DOMParser {
|
||||
|
|
|
@ -386,8 +386,7 @@ pub mod serviceworker;
|
|||
pub mod serviceworkercontainer;
|
||||
pub mod serviceworkerglobalscope;
|
||||
pub mod serviceworkerregistration;
|
||||
pub mod servohtmlparser;
|
||||
pub mod servoxmlparser;
|
||||
pub mod servoparser;
|
||||
pub mod storage;
|
||||
pub mod storageevent;
|
||||
pub mod stylesheet;
|
||||
|
|
|
@ -47,6 +47,7 @@ use dom::htmltextareaelement::{HTMLTextAreaElement, LayoutHTMLTextAreaElementHel
|
|||
use dom::nodelist::NodeList;
|
||||
use dom::processinginstruction::ProcessingInstruction;
|
||||
use dom::range::WeakRangeVec;
|
||||
use dom::servoparser::html::parse_html_fragment;
|
||||
use dom::svgsvgelement::{SVGSVGElement, LayoutSVGSVGElementHelpers};
|
||||
use dom::text::Text;
|
||||
use dom::virtualmethods::{VirtualMethods, vtable_for};
|
||||
|
@ -59,7 +60,6 @@ use html5ever::tree_builder::QuirksMode;
|
|||
use js::jsapi::{JSContext, JSObject, JSRuntime};
|
||||
use libc::{self, c_void, uintptr_t};
|
||||
use msg::constellation_msg::PipelineId;
|
||||
use parse::html::parse_html_fragment;
|
||||
use ref_slice::ref_slice;
|
||||
use script_layout_interface::{HTMLCanvasData, OpaqueStyleAndLayoutData, SVGSVGData};
|
||||
use script_layout_interface::{LayoutElementType, LayoutNodeType, TrustedNodeAddress};
|
||||
|
|
339
components/script/dom/servoparser/html.rs
Normal file
339
components/script/dom/servoparser/html.rs
Normal file
|
@ -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();
|
||||
}
|
||||
}
|
|
@ -2,15 +2,12 @@
|
|||
* 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/. */
|
||||
|
||||
//! The bulk of the HTML parser integration is in `script::parse::html`.
|
||||
//! This module is mostly about its interaction with DOM memory management.
|
||||
|
||||
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::ServoHTMLParserBinding;
|
||||
use dom::bindings::codegen::Bindings::ServoParserBinding;
|
||||
use dom::bindings::inheritance::Castable;
|
||||
use dom::bindings::js::{JS, Root};
|
||||
use dom::bindings::refcounted::Trusted;
|
||||
|
@ -21,12 +18,11 @@ use dom::document::Document;
|
|||
use dom::globalscope::GlobalScope;
|
||||
use dom::htmlimageelement::HTMLImageElement;
|
||||
use dom::node::Node;
|
||||
use dom::window::Window;
|
||||
use encoding::all::UTF_8;
|
||||
use encoding::types::{DecoderTrap, Encoding};
|
||||
use html5ever::tokenizer;
|
||||
use html5ever::tree_builder;
|
||||
use html5ever::tree_builder::{TreeBuilder, TreeBuilderOpts};
|
||||
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;
|
||||
|
@ -34,36 +30,288 @@ use js::jsapi::JSTracer;
|
|||
use msg::constellation_msg::PipelineId;
|
||||
use net_traits::{AsyncResponseListener, Metadata, NetworkError};
|
||||
use network_listener::PreInvoke;
|
||||
use parse::{Parser, ParserRef, TrustedParser};
|
||||
use profile_traits::time::{TimerMetadata, TimerMetadataFrameType, TimerMetadataReflowType, profile};
|
||||
use profile_traits::time::ProfilerCategory;
|
||||
use profile_traits::time::{TimerMetadata, TimerMetadataFrameType};
|
||||
use profile_traits::time::{TimerMetadataReflowType, ProfilerCategory, profile};
|
||||
use script_thread::ScriptThread;
|
||||
use std::cell::Cell;
|
||||
use std::default::Default;
|
||||
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)]
|
||||
pub struct Sink {
|
||||
pub base_url: Option<Url>,
|
||||
#[must_root]
|
||||
struct Sink {
|
||||
pub base_url: Url,
|
||||
pub document: JS<Document>,
|
||||
}
|
||||
|
||||
/// 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>,
|
||||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub type Tokenizer = tokenizer::Tokenizer<TreeBuilder<JS<Node>, Sink>>;
|
||||
impl JSTraceable for Tokenizer {
|
||||
fn trace(&self, trc: *mut JSTracer) {
|
||||
struct Tracer(*mut JSTracer);
|
||||
let tracer = Tracer(trc);
|
||||
|
||||
/// The context required for asynchronously fetching a document and parsing it progressively.
|
||||
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<TrustedParser>,
|
||||
parser: Option<Trusted<ServoParser>>,
|
||||
/// Is this a synthesized document
|
||||
is_synthesized_document: bool,
|
||||
/// The pipeline associated with this document.
|
||||
|
@ -105,19 +353,13 @@ impl AsyncResponseListener for ParserContext {
|
|||
None => return,
|
||||
};
|
||||
|
||||
let parser = parser.r();
|
||||
self.parser = Some(match parser {
|
||||
ParserRef::HTML(parser) => TrustedParser::HTML(
|
||||
Trusted::new(parser)),
|
||||
ParserRef::XML(parser) => TrustedParser::XML(
|
||||
Trusted::new(parser)),
|
||||
});
|
||||
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.pending_input().borrow_mut().push(page);
|
||||
parser.push_input_chunk(page);
|
||||
parser.parse_sync();
|
||||
|
||||
let doc = parser.document();
|
||||
|
@ -130,7 +372,7 @@ impl AsyncResponseListener for ParserContext {
|
|||
Some(ContentType(Mime(TopLevel::Text, SubLevel::Plain, _))) => {
|
||||
// https://html.spec.whatwg.org/multipage/#read-text
|
||||
let page = "<pre>\n".into();
|
||||
parser.pending_input().borrow_mut().push(page);
|
||||
parser.push_input_chunk(page);
|
||||
parser.parse_sync();
|
||||
parser.set_plaintext_state();
|
||||
},
|
||||
|
@ -140,7 +382,7 @@ impl AsyncResponseListener for ParserContext {
|
|||
let page_bytes = read_resource_file("badcert.html").unwrap();
|
||||
let page = String::from_utf8(page_bytes).unwrap();
|
||||
let page = page.replace("${reason}", &reason);
|
||||
parser.pending_input().borrow_mut().push(page);
|
||||
parser.push_input_chunk(page);
|
||||
parser.parse_sync();
|
||||
}
|
||||
},
|
||||
|
@ -155,7 +397,7 @@ impl AsyncResponseListener for ParserContext {
|
|||
let page = format!("<html><body><p>Unknown content type ({}/{}).</p></body></html>",
|
||||
toplevel.as_str(), sublevel.as_str());
|
||||
self.is_synthesized_document = true;
|
||||
parser.pending_input().borrow_mut().push(page);
|
||||
parser.push_input_chunk(page);
|
||||
parser.parse_sync();
|
||||
},
|
||||
None => {
|
||||
|
@ -173,7 +415,7 @@ impl AsyncResponseListener for ParserContext {
|
|||
Some(parser) => parser.root(),
|
||||
None => return,
|
||||
};
|
||||
parser.r().parse_chunk(data);
|
||||
parser.parse_chunk(data);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -187,245 +429,24 @@ impl AsyncResponseListener for ParserContext {
|
|||
// Show an error page for network errors,
|
||||
// certificate errors are handled earlier.
|
||||
self.is_synthesized_document = true;
|
||||
let parser = parser.r();
|
||||
let page_bytes = read_resource_file("neterror.html").unwrap();
|
||||
let page = String::from_utf8(page_bytes).unwrap();
|
||||
let page = page.replace("${reason}", reason);
|
||||
parser.pending_input().borrow_mut().push(page);
|
||||
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.r().document().finish_load(LoadType::PageSource(self.url.clone()));
|
||||
parser.document()
|
||||
.finish_load(LoadType::PageSource(self.url.clone()));
|
||||
|
||||
parser.r().last_chunk_received().set(true);
|
||||
if !parser.r().is_suspended() {
|
||||
parser.r().parse_sync();
|
||||
parser.mark_last_chunk_received();
|
||||
if !parser.is_suspended() {
|
||||
parser.parse_sync();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PreInvoke for ParserContext {
|
||||
}
|
||||
|
||||
#[dom_struct]
|
||||
pub struct ServoHTMLParser {
|
||||
reflector_: Reflector,
|
||||
#[ignore_heap_size_of = "Defined in html5ever"]
|
||||
tokenizer: DOMRefCell<Tokenizer>,
|
||||
/// Input chunks received but not yet passed to the parser.
|
||||
pending_input: DOMRefCell<Vec<String>>,
|
||||
/// The document associated with this parser.
|
||||
document: JS<Document>,
|
||||
/// True if this parser should avoid passing any further data to the tokenizer.
|
||||
suspended: Cell<bool>,
|
||||
/// Whether to expect any further input from the associated network request.
|
||||
last_chunk_received: Cell<bool>,
|
||||
/// The pipeline associated with this parse, unavailable if this parse does not
|
||||
/// correspond to a page load.
|
||||
pipeline: Option<PipelineId>,
|
||||
}
|
||||
|
||||
impl<'a> Parser for &'a ServoHTMLParser {
|
||||
fn parse_chunk(self, input: String) {
|
||||
self.document.set_current_parser(Some(ParserRef::HTML(self)));
|
||||
self.pending_input.borrow_mut().push(input);
|
||||
if !self.is_suspended() {
|
||||
self.parse_sync();
|
||||
}
|
||||
}
|
||||
|
||||
fn finish(self) {
|
||||
assert!(!self.suspended.get());
|
||||
assert!(self.pending_input.borrow().is_empty());
|
||||
|
||||
self.tokenizer.borrow_mut().end();
|
||||
debug!("finished parsing");
|
||||
|
||||
self.document.set_current_parser(None);
|
||||
|
||||
if let Some(pipeline) = self.pipeline {
|
||||
ScriptThread::parsing_complete(pipeline);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ServoHTMLParser {
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(base_url: Option<Url>, document: &Document, pipeline: Option<PipelineId>)
|
||||
-> Root<ServoHTMLParser> {
|
||||
let sink = Sink {
|
||||
base_url: base_url,
|
||||
document: JS::from_ref(document),
|
||||
};
|
||||
|
||||
let tb = TreeBuilder::new(sink, TreeBuilderOpts {
|
||||
ignore_missing_rules: true,
|
||||
.. Default::default()
|
||||
});
|
||||
|
||||
let tok = tokenizer::Tokenizer::new(tb, Default::default());
|
||||
|
||||
let parser = ServoHTMLParser {
|
||||
reflector_: Reflector::new(),
|
||||
tokenizer: DOMRefCell::new(tok),
|
||||
pending_input: DOMRefCell::new(vec!()),
|
||||
document: JS::from_ref(document),
|
||||
suspended: Cell::new(false),
|
||||
last_chunk_received: Cell::new(false),
|
||||
pipeline: pipeline,
|
||||
};
|
||||
|
||||
reflect_dom_object(box parser, document.window(), ServoHTMLParserBinding::Wrap)
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new_for_fragment(base_url: Option<Url>, document: &Document,
|
||||
fragment_context: FragmentContext) -> Root<ServoHTMLParser> {
|
||||
let sink = Sink {
|
||||
base_url: base_url,
|
||||
document: JS::from_ref(document),
|
||||
};
|
||||
|
||||
let tb_opts = TreeBuilderOpts {
|
||||
ignore_missing_rules: true,
|
||||
.. Default::default()
|
||||
};
|
||||
let tb = TreeBuilder::new_for_fragment(sink,
|
||||
JS::from_ref(fragment_context.context_elem),
|
||||
fragment_context.form_elem.map(|n| JS::from_ref(n)),
|
||||
tb_opts);
|
||||
|
||||
let tok_opts = tokenizer::TokenizerOpts {
|
||||
initial_state: Some(tb.tokenizer_state_for_context_elem()),
|
||||
.. Default::default()
|
||||
};
|
||||
let tok = tokenizer::Tokenizer::new(tb, tok_opts);
|
||||
|
||||
let parser = ServoHTMLParser {
|
||||
reflector_: Reflector::new(),
|
||||
tokenizer: DOMRefCell::new(tok),
|
||||
pending_input: DOMRefCell::new(vec!()),
|
||||
document: JS::from_ref(document),
|
||||
suspended: Cell::new(false),
|
||||
last_chunk_received: Cell::new(true),
|
||||
pipeline: None,
|
||||
};
|
||||
|
||||
reflect_dom_object(box parser, document.window(), ServoHTMLParserBinding::Wrap)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn tokenizer(&self) -> &DOMRefCell<Tokenizer> {
|
||||
&self.tokenizer
|
||||
}
|
||||
|
||||
pub fn set_plaintext_state(&self) {
|
||||
self.tokenizer.borrow_mut().set_plaintext_state()
|
||||
}
|
||||
|
||||
pub fn end_tokenizer(&self) {
|
||||
self.tokenizer.borrow_mut().end()
|
||||
}
|
||||
|
||||
pub fn pending_input(&self) -> &DOMRefCell<Vec<String>> {
|
||||
&self.pending_input
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
impl ServoHTMLParser {
|
||||
pub fn parse_sync(&self) {
|
||||
let metadata = TimerMetadata {
|
||||
url: self.document.url().as_str().into(),
|
||||
iframe: TimerMetadataFrameType::RootWindow,
|
||||
incremental: TimerMetadataReflowType::FirstReflow,
|
||||
};
|
||||
profile(ProfilerCategory::ScriptParseHTML,
|
||||
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();
|
||||
let mut pending_input = self.pending_input.borrow_mut();
|
||||
if !pending_input.is_empty() {
|
||||
let chunk = pending_input.remove(0);
|
||||
self.tokenizer.borrow_mut().feed(chunk.into());
|
||||
} else {
|
||||
self.tokenizer.borrow_mut().run();
|
||||
}
|
||||
|
||||
// Document parsing is blocked on an external resource.
|
||||
if self.suspended.get() {
|
||||
return;
|
||||
}
|
||||
|
||||
if pending_input.is_empty() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if self.last_chunk_received.get() {
|
||||
self.finish();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn window(&self) -> &Window {
|
||||
self.document.window()
|
||||
}
|
||||
|
||||
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()
|
||||
}
|
||||
|
||||
pub fn document(&self) -> &Document {
|
||||
&self.document
|
||||
}
|
||||
|
||||
pub fn last_chunk_received(&self) -> &Cell<bool> {
|
||||
&self.last_chunk_received
|
||||
}
|
||||
}
|
||||
|
||||
struct Tracer {
|
||||
trc: *mut JSTracer,
|
||||
}
|
||||
|
||||
impl tree_builder::Tracer for Tracer {
|
||||
type Handle = JS<Node>;
|
||||
#[allow(unrooted_must_root)]
|
||||
fn trace_handle(&self, node: &JS<Node>) {
|
||||
node.trace(self.trc);
|
||||
}
|
||||
}
|
||||
|
||||
impl JSTraceable for Tokenizer {
|
||||
fn trace(&self, trc: *mut JSTracer) {
|
||||
let tracer = Tracer {
|
||||
trc: trc,
|
||||
};
|
||||
let tracer = &tracer as &tree_builder::Tracer<Handle=JS<Node>>;
|
||||
|
||||
let tree_builder = self.sink();
|
||||
tree_builder.trace_handles(tracer);
|
||||
tree_builder.sink().trace(trc);
|
||||
}
|
||||
}
|
||||
impl PreInvoke for ParserContext {}
|
147
components/script/dom/servoparser/xml.rs
Normal file
147
components/script/dom/servoparser/xml.rs
Normal file
|
@ -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));
|
||||
}
|
|
@ -1,195 +0,0 @@
|
|||
/* 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 dom::bindings::cell::DOMRefCell;
|
||||
use dom::bindings::codegen::Bindings::ServoXMLParserBinding;
|
||||
use dom::bindings::js::{JS, Root};
|
||||
use dom::bindings::reflector::{Reflector, reflect_dom_object};
|
||||
use dom::bindings::trace::JSTraceable;
|
||||
use dom::document::Document;
|
||||
use dom::node::Node;
|
||||
use dom::window::Window;
|
||||
use js::jsapi::JSTracer;
|
||||
use msg::constellation_msg::PipelineId;
|
||||
use parse::{Parser, ParserRef};
|
||||
use script_thread::ScriptThread;
|
||||
use std::cell::Cell;
|
||||
use url::Url;
|
||||
use xml5ever::tokenizer;
|
||||
use xml5ever::tree_builder::{self, XmlTreeBuilder};
|
||||
|
||||
pub type Tokenizer = tokenizer::XmlTokenizer<XmlTreeBuilder<JS<Node>, Sink>>;
|
||||
|
||||
#[must_root]
|
||||
#[derive(JSTraceable, HeapSizeOf)]
|
||||
pub struct Sink {
|
||||
pub base_url: Option<Url>,
|
||||
pub document: JS<Document>,
|
||||
}
|
||||
|
||||
#[must_root]
|
||||
#[dom_struct]
|
||||
pub struct ServoXMLParser {
|
||||
reflector_: Reflector,
|
||||
#[ignore_heap_size_of = "Defined in xml5ever"]
|
||||
tokenizer: DOMRefCell<Tokenizer>,
|
||||
/// Input chunks received but not yet passed to the parser.
|
||||
pending_input: DOMRefCell<Vec<String>>,
|
||||
/// The document associated with this parser.
|
||||
document: JS<Document>,
|
||||
/// True if this parser should avoid passing any further data to the tokenizer.
|
||||
suspended: Cell<bool>,
|
||||
/// Whether to expect any further input from the associated network request.
|
||||
last_chunk_received: Cell<bool>,
|
||||
/// The pipeline associated with this parse, unavailable if this parse does not
|
||||
/// correspond to a page load.
|
||||
pipeline: Option<PipelineId>,
|
||||
}
|
||||
|
||||
impl<'a> Parser for &'a ServoXMLParser {
|
||||
fn parse_chunk(self, input: String) {
|
||||
self.document.set_current_parser(Some(ParserRef::XML(self)));
|
||||
self.pending_input.borrow_mut().push(input);
|
||||
if !self.is_suspended() {
|
||||
self.parse_sync();
|
||||
}
|
||||
}
|
||||
|
||||
fn finish(self) {
|
||||
assert!(!self.suspended.get());
|
||||
assert!(self.pending_input.borrow().is_empty());
|
||||
|
||||
self.tokenizer.borrow_mut().end();
|
||||
debug!("finished parsing");
|
||||
|
||||
self.document.set_current_parser(None);
|
||||
|
||||
if let Some(pipeline) = self.pipeline {
|
||||
ScriptThread::parsing_complete(pipeline);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ServoXMLParser {
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(base_url: Option<Url>, document: &Document, pipeline: Option<PipelineId>)
|
||||
-> Root<ServoXMLParser> {
|
||||
let sink = Sink {
|
||||
base_url: base_url,
|
||||
document: JS::from_ref(document),
|
||||
};
|
||||
|
||||
let tb = XmlTreeBuilder::new(sink);
|
||||
|
||||
let tok = tokenizer::XmlTokenizer::new(tb, Default::default());
|
||||
|
||||
let parser = ServoXMLParser {
|
||||
reflector_: Reflector::new(),
|
||||
tokenizer: DOMRefCell::new(tok),
|
||||
pending_input: DOMRefCell::new(vec!()),
|
||||
document: JS::from_ref(document),
|
||||
suspended: Cell::new(false),
|
||||
last_chunk_received: Cell::new(false),
|
||||
pipeline: pipeline,
|
||||
};
|
||||
|
||||
reflect_dom_object(box parser, document.window(), ServoXMLParserBinding::Wrap)
|
||||
}
|
||||
|
||||
pub fn window(&self) -> &Window {
|
||||
self.document.window()
|
||||
}
|
||||
|
||||
pub fn resume(&self) {
|
||||
assert!(self.suspended.get());
|
||||
self.suspended.set(false);
|
||||
self.parse_sync();
|
||||
}
|
||||
|
||||
pub fn suspend(&self) {
|
||||
assert!(!self.suspended.get());
|
||||
self.suspended.set(true);
|
||||
}
|
||||
|
||||
pub fn is_suspended(&self) -> bool {
|
||||
self.suspended.get()
|
||||
}
|
||||
|
||||
pub fn 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();
|
||||
let mut pending_input = self.pending_input.borrow_mut();
|
||||
if !pending_input.is_empty() {
|
||||
let chunk = pending_input.remove(0);
|
||||
self.tokenizer.borrow_mut().feed(chunk.into());
|
||||
} else {
|
||||
self.tokenizer.borrow_mut().run();
|
||||
}
|
||||
|
||||
// Document parsing is blocked on an external resource.
|
||||
if self.suspended.get() {
|
||||
return;
|
||||
}
|
||||
|
||||
if pending_input.is_empty() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if self.last_chunk_received.get() {
|
||||
self.finish();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn pending_input(&self) -> &DOMRefCell<Vec<String>> {
|
||||
&self.pending_input
|
||||
}
|
||||
|
||||
pub fn set_plaintext_state(&self) {
|
||||
//self.tokenizer.borrow_mut().set_plaintext_state()
|
||||
}
|
||||
|
||||
pub fn end_tokenizer(&self) {
|
||||
self.tokenizer.borrow_mut().end()
|
||||
}
|
||||
|
||||
pub fn document(&self) -> &Document {
|
||||
&self.document
|
||||
}
|
||||
|
||||
pub fn last_chunk_received(&self) -> &Cell<bool> {
|
||||
&self.last_chunk_received
|
||||
}
|
||||
|
||||
pub fn tokenizer(&self) -> &DOMRefCell<Tokenizer> {
|
||||
&self.tokenizer
|
||||
}
|
||||
}
|
||||
|
||||
struct Tracer {
|
||||
trc: *mut JSTracer,
|
||||
}
|
||||
|
||||
impl tree_builder::Tracer for Tracer {
|
||||
type Handle = JS<Node>;
|
||||
#[allow(unrooted_must_root)]
|
||||
fn trace_handle(&self, node: JS<Node>) {
|
||||
node.trace(self.trc);
|
||||
}
|
||||
}
|
||||
|
||||
impl JSTraceable for Tokenizer {
|
||||
fn trace(&self, trc: *mut JSTracer) {
|
||||
let tracer = Tracer {
|
||||
trc: trc,
|
||||
};
|
||||
let tracer = &tracer as &tree_builder::Tracer<Handle=JS<Node>>;
|
||||
|
||||
let tree_builder = self.sink();
|
||||
tree_builder.trace_handles(tracer);
|
||||
tree_builder.sink().trace(trc);
|
||||
}
|
||||
}
|
|
@ -1,11 +0,0 @@
|
|||
/* 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/. */
|
||||
|
||||
// This interface is entirely internal to Servo, and should not be accessible to
|
||||
// web pages.
|
||||
|
||||
// FIXME: find a better way to hide this from content (#3688)
|
||||
[NoInterfaceObject, Exposed=(Window,Worker)]
|
||||
interface ServoHTMLParser {
|
||||
};
|
|
@ -5,7 +5,6 @@
|
|||
// This interface is entirely internal to Servo, and should not be accessible to
|
||||
// web pages.
|
||||
|
||||
[NoInterfaceObject, Exposed=(Window,Worker)]
|
||||
interface ServoXMLParser {
|
||||
};
|
||||
|
||||
[Exposed=(Window,Worker),
|
||||
NoInterfaceObject]
|
||||
interface ServoParser {};
|
|
@ -28,6 +28,8 @@ use dom::globalscope::GlobalScope;
|
|||
use dom::headers::is_forbidden_header_name;
|
||||
use dom::htmlformelement::{encode_multipart_form_data, generate_boundary};
|
||||
use dom::progressevent::ProgressEvent;
|
||||
use dom::servoparser::html::{ParseContext, parse_html};
|
||||
use dom::servoparser::xml::{self, parse_xml};
|
||||
use dom::window::Window;
|
||||
use dom::workerglobalscope::WorkerGlobalScope;
|
||||
use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
|
||||
|
@ -53,8 +55,6 @@ use net_traits::CoreResourceMsg::Fetch;
|
|||
use net_traits::request::{CredentialsMode, Destination, RequestInit, RequestMode};
|
||||
use net_traits::trim_http_whitespace;
|
||||
use network_listener::{NetworkListener, PreInvoke};
|
||||
use parse::html::{ParseContext, parse_html};
|
||||
use parse::xml::{self, parse_xml};
|
||||
use script_runtime::ScriptChan;
|
||||
use std::ascii::AsciiExt;
|
||||
use std::borrow::ToOwned;
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue