mirror of
https://github.com/servo/servo.git
synced 2025-08-06 14:10:11 +01:00
Unify ServoHTMLParser and ServoXMLParser in ServoParser
This commit is contained in:
parent
609299e1e4
commit
1405be6917
12 changed files with 300 additions and 646 deletions
|
@ -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()
|
||||
}
|
||||
|
||||
|
|
|
@ -386,9 +386,7 @@ pub mod serviceworker;
|
|||
pub mod serviceworkercontainer;
|
||||
pub mod serviceworkerglobalscope;
|
||||
pub mod serviceworkerregistration;
|
||||
pub mod servohtmlparser;
|
||||
pub mod servoparser;
|
||||
pub mod servoxmlparser;
|
||||
pub mod storage;
|
||||
pub mod storageevent;
|
||||
pub mod stylesheet;
|
||||
|
|
|
@ -1,235 +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/. */
|
||||
|
||||
//! The bulk of the HTML parser integration is in `script::parse::html`.
|
||||
//! This module is mostly about its interaction with DOM memory management.
|
||||
|
||||
use dom::bindings::cell::DOMRefCell;
|
||||
use dom::bindings::codegen::Bindings::ServoHTMLParserBinding;
|
||||
use dom::bindings::inheritance::Castable;
|
||||
use dom::bindings::js::{JS, Root};
|
||||
use dom::bindings::reflector::reflect_dom_object;
|
||||
use dom::bindings::trace::JSTraceable;
|
||||
use dom::document::Document;
|
||||
use dom::globalscope::GlobalScope;
|
||||
use dom::node::Node;
|
||||
use dom::servoparser::ServoParser;
|
||||
use dom::window::Window;
|
||||
use html5ever::tokenizer;
|
||||
use html5ever::tree_builder;
|
||||
use html5ever::tree_builder::{TreeBuilder, TreeBuilderOpts};
|
||||
use js::jsapi::JSTracer;
|
||||
use msg::constellation_msg::PipelineId;
|
||||
use parse::{Parser, ParserRef};
|
||||
use profile_traits::time::{TimerMetadata, TimerMetadataFrameType, TimerMetadataReflowType, profile};
|
||||
use profile_traits::time::ProfilerCategory;
|
||||
use script_thread::ScriptThread;
|
||||
use std::cell::Cell;
|
||||
use std::default::Default;
|
||||
use url::Url;
|
||||
|
||||
#[must_root]
|
||||
#[derive(JSTraceable, HeapSizeOf)]
|
||||
pub struct Sink {
|
||||
pub base_url: Option<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>,
|
||||
}
|
||||
|
||||
pub type Tokenizer = tokenizer::Tokenizer<TreeBuilder<JS<Node>, Sink>>;
|
||||
|
||||
#[dom_struct]
|
||||
pub struct ServoHTMLParser {
|
||||
servoparser: ServoParser,
|
||||
#[ignore_heap_size_of = "Defined in html5ever"]
|
||||
tokenizer: DOMRefCell<Tokenizer>,
|
||||
/// True if this parser should avoid passing any further data to the tokenizer.
|
||||
suspended: Cell<bool>,
|
||||
}
|
||||
|
||||
impl<'a> Parser for &'a ServoHTMLParser {
|
||||
fn parse_chunk(self, input: String) {
|
||||
self.upcast().document().set_current_parser(Some(ParserRef::HTML(self)));
|
||||
self.upcast().push_input_chunk(input);
|
||||
if !self.is_suspended() {
|
||||
self.parse_sync();
|
||||
}
|
||||
}
|
||||
|
||||
fn finish(self) {
|
||||
assert!(!self.suspended.get());
|
||||
assert!(!self.upcast().has_pending_input());
|
||||
|
||||
self.tokenizer.borrow_mut().end();
|
||||
debug!("finished parsing");
|
||||
|
||||
self.upcast().document().set_current_parser(None);
|
||||
|
||||
if let Some(pipeline) = self.upcast().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 {
|
||||
servoparser: ServoParser::new_inherited(document, pipeline, false),
|
||||
tokenizer: DOMRefCell::new(tok),
|
||||
suspended: Cell::new(false),
|
||||
};
|
||||
|
||||
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 {
|
||||
servoparser: ServoParser::new_inherited(document, None, true),
|
||||
tokenizer: DOMRefCell::new(tok),
|
||||
suspended: Cell::new(false),
|
||||
};
|
||||
|
||||
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()
|
||||
}
|
||||
}
|
||||
|
||||
impl ServoHTMLParser {
|
||||
pub fn parse_sync(&self) {
|
||||
let metadata = TimerMetadata {
|
||||
url: self.upcast().document().url().as_str().into(),
|
||||
iframe: TimerMetadataFrameType::RootWindow,
|
||||
incremental: TimerMetadataReflowType::FirstReflow,
|
||||
};
|
||||
profile(ProfilerCategory::ScriptParseHTML,
|
||||
Some(metadata),
|
||||
self.upcast().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.upcast().document().reflow_if_reflow_timer_expired();
|
||||
if let Some(chunk) = self.upcast().take_next_input_chunk() {
|
||||
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 !self.upcast().has_pending_input() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if self.upcast().last_chunk_received() {
|
||||
self.finish();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn window(&self) -> &Window {
|
||||
self.upcast().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()
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
|
@ -3,11 +3,27 @@
|
|||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use dom::bindings::cell::DOMRefCell;
|
||||
use dom::bindings::reflector::Reflector;
|
||||
use dom::bindings::js::JS;
|
||||
use dom::bindings::codegen::Bindings::ServoParserBinding;
|
||||
use dom::bindings::inheritance::Castable;
|
||||
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::globalscope::GlobalScope;
|
||||
use dom::node::Node;
|
||||
use dom::window::Window;
|
||||
use html5ever::tokenizer::Tokenizer as HtmlTokenizer;
|
||||
use html5ever::tree_builder::Tracer as HtmlTracer;
|
||||
use html5ever::tree_builder::TreeBuilder as HtmlTreeBuilder;
|
||||
use js::jsapi::JSTracer;
|
||||
use msg::constellation_msg::PipelineId;
|
||||
use parse::Sink;
|
||||
use profile_traits::time::{TimerMetadata, TimerMetadataFrameType};
|
||||
use profile_traits::time::{TimerMetadataReflowType, ProfilerCategory, profile};
|
||||
use script_thread::ScriptThread;
|
||||
use std::cell::Cell;
|
||||
use xml5ever::tokenizer::XmlTokenizer;
|
||||
use xml5ever::tree_builder::{Tracer as XmlTracer, XmlTreeBuilder};
|
||||
|
||||
#[dom_struct]
|
||||
pub struct ServoParser {
|
||||
|
@ -19,14 +35,20 @@ pub struct ServoParser {
|
|||
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>,
|
||||
}
|
||||
|
||||
impl ServoParser {
|
||||
pub fn new_inherited(
|
||||
#[allow(unrooted_must_root)]
|
||||
fn new_inherited(
|
||||
document: &Document,
|
||||
pipeline: Option<PipelineId>,
|
||||
tokenizer: Tokenizer,
|
||||
last_chunk_received: bool)
|
||||
-> Self {
|
||||
ServoParser {
|
||||
|
@ -34,10 +56,25 @@ impl ServoParser {
|
|||
document: JS::from_ref(document),
|
||||
pipeline: pipeline,
|
||||
pending_input: DOMRefCell::new(vec![]),
|
||||
tokenizer: DOMRefCell::new(tokenizer),
|
||||
last_chunk_received: Cell::new(last_chunk_received),
|
||||
suspended: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn new(
|
||||
document: &Document,
|
||||
pipeline: Option<PipelineId>,
|
||||
tokenizer: Tokenizer,
|
||||
last_chunk_received: bool)
|
||||
-> Root<Self> {
|
||||
reflect_dom_object(
|
||||
box ServoParser::new_inherited(document, pipeline, tokenizer, last_chunk_received),
|
||||
document.window(),
|
||||
ServoParserBinding::Wrap)
|
||||
}
|
||||
|
||||
pub fn document(&self) -> &Document {
|
||||
&self.document
|
||||
}
|
||||
|
@ -70,4 +107,176 @@ impl ServoParser {
|
|||
pub fn mark_last_chunk_received(&self) {
|
||||
self.last_chunk_received.set(true)
|
||||
}
|
||||
|
||||
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 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 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();
|
||||
}
|
||||
}
|
||||
|
||||
pub 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();
|
||||
}
|
||||
}
|
||||
|
||||
pub 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]
|
||||
pub 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>>
|
||||
),
|
||||
}
|
||||
|
||||
impl Tokenizer {
|
||||
pub 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()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run(&mut self) {
|
||||
match *self {
|
||||
Tokenizer::HTML(ref mut tokenizer) => tokenizer.run(),
|
||||
Tokenizer::XML(ref mut tokenizer) => tokenizer.run(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn end(&mut self) {
|
||||
match *self {
|
||||
Tokenizer::HTML(ref mut tokenizer) => tokenizer.end(),
|
||||
Tokenizer::XML(ref mut tokenizer) => tokenizer.end(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_plaintext_state(&mut self) {
|
||||
match *self {
|
||||
Tokenizer::HTML(ref mut tokenizer) => tokenizer.set_plaintext_state(),
|
||||
Tokenizer::XML(_) => { /* todo */ },
|
||||
}
|
||||
}
|
||||
|
||||
pub 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,185 +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::inheritance::Castable;
|
||||
use dom::bindings::js::{JS, Root};
|
||||
use dom::bindings::reflector::reflect_dom_object;
|
||||
use dom::bindings::trace::JSTraceable;
|
||||
use dom::document::Document;
|
||||
use dom::globalscope::GlobalScope;
|
||||
use dom::node::Node;
|
||||
use dom::servoparser::ServoParser;
|
||||
use dom::window::Window;
|
||||
use js::jsapi::JSTracer;
|
||||
use msg::constellation_msg::PipelineId;
|
||||
use parse::{Parser, ParserRef};
|
||||
use profile_traits::time::{ProfilerCategory, TimerMetadata};
|
||||
use profile_traits::time::{TimerMetadataFrameType, TimerMetadataReflowType, profile};
|
||||
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 {
|
||||
servoparser: ServoParser,
|
||||
#[ignore_heap_size_of = "Defined in xml5ever"]
|
||||
tokenizer: DOMRefCell<Tokenizer>,
|
||||
/// True if this parser should avoid passing any further data to the tokenizer.
|
||||
suspended: Cell<bool>,
|
||||
}
|
||||
|
||||
impl<'a> Parser for &'a ServoXMLParser {
|
||||
fn parse_chunk(self, input: String) {
|
||||
self.upcast().document().set_current_parser(Some(ParserRef::XML(self)));
|
||||
self.upcast().push_input_chunk(input);
|
||||
if !self.is_suspended() {
|
||||
self.parse_sync();
|
||||
}
|
||||
}
|
||||
|
||||
fn finish(self) {
|
||||
assert!(!self.suspended.get());
|
||||
assert!(!self.upcast().has_pending_input());
|
||||
|
||||
self.tokenizer.borrow_mut().end();
|
||||
debug!("finished parsing");
|
||||
|
||||
self.upcast().document().set_current_parser(None);
|
||||
|
||||
if let Some(pipeline) = self.upcast().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 {
|
||||
servoparser: ServoParser::new_inherited(document, pipeline, false),
|
||||
tokenizer: DOMRefCell::new(tok),
|
||||
suspended: Cell::new(false),
|
||||
};
|
||||
|
||||
reflect_dom_object(box parser, document.window(), ServoXMLParserBinding::Wrap)
|
||||
}
|
||||
|
||||
pub fn window(&self) -> &Window {
|
||||
self.upcast().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) {
|
||||
let metadata = TimerMetadata {
|
||||
url: self.upcast().document().url().as_str().into(),
|
||||
iframe: TimerMetadataFrameType::RootWindow,
|
||||
incremental: TimerMetadataReflowType::FirstReflow,
|
||||
};
|
||||
profile(ProfilerCategory::ScriptParseXML,
|
||||
Some(metadata),
|
||||
self.upcast().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.upcast().document().reflow_if_reflow_timer_expired();
|
||||
if let Some(chunk) = self.upcast().take_next_input_chunk() {
|
||||
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 !self.upcast().has_pending_input() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if self.upcast().last_chunk_received() {
|
||||
self.finish();
|
||||
}
|
||||
}
|
||||
|
||||
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 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 : ServoParser {
|
||||
};
|
|
@ -6,5 +6,5 @@
|
|||
// web pages.
|
||||
|
||||
[Exposed=(Window,Worker),
|
||||
Inline]
|
||||
NoInterfaceObject]
|
||||
interface ServoParser {};
|
||||
|
|
|
@ -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.
|
||||
|
||||
[NoInterfaceObject, Exposed=(Window,Worker)]
|
||||
interface ServoXMLParser : ServoParser {
|
||||
};
|
||||
|
Loading…
Add table
Add a link
Reference in a new issue