Struct script::dom::servoparser::ServoParser

#[repr(C)]
pub struct ServoParser {

    reflector: Reflector,
    document: Dom<Document>,
    bom_sniff: DomRefCell<Option<Vec<u8>>>,
    network_decoder: DomRefCell<Option<NetworkDecoder>>,
    network_input: BufferQueue,
    script_input: BufferQueue,
    tokenizer: Tokenizer,
    last_chunk_received: Cell<bool>,
    suspended: Cell<bool>,
    script_nesting_level: Cell<usize>,
    aborted: Cell<bool>,
    script_created_parser: bool,
    prefetch_tokenizer: Tokenizer,
    prefetch_input: BufferQueue,
}

The parser maintains two input streams: one for input from script through document.write(), and one for input from network.

There is no concrete representation of the insertion point, instead it always points to just before the next character from the network input, with all of the script input before itself.

    ... script input ... | ... network input ...
                         ^
                insertion point

Fields

reflector: Reflector

document: Dom<Document>

The document associated with this parser.

bom_sniff: DomRefCell<Option<Vec<u8>>>

The BOM sniffing state.

None means we’ve found the BOM, we’ve found there isn’t one, or we’re not parsing from a byte stream. Some contains the BOM bytes found so far.

network_decoder: DomRefCell<Option<NetworkDecoder>>

The decoder used for the network input.

network_input: BufferQueue

Input received from network.

script_input: BufferQueue

Input received from script. Used only to support document.write().

tokenizer: Tokenizer

The tokenizer of this parser.

last_chunk_received: Cell<bool>

Whether to expect any further input from the associated network request.

suspended: Cell<bool>

Whether this parser should avoid passing any further data to the tokenizer.

script_nesting_level: Cell<usize>

https://html.spec.whatwg.org/multipage/#script-nesting-level

aborted: Cell<bool>

https://html.spec.whatwg.org/multipage/#abort-a-parser

script_created_parser: bool

https://html.spec.whatwg.org/multipage/#script-created-parser

prefetch_tokenizer: Tokenizer

We do a quick-and-dirty parse of the input looking for resources to prefetch.

prefetch_input: BufferQueue

Implementations

impl ServoParser

fn __assert_parent_type(&self)

impl ServoParser

pub fn parser_is_not_active(&self) -> bool

pub fn parse_html_document( document: &Document, input: Option<DOMString>, url: ServoUrl, can_gc: CanGc, )

pub fn parse_html_fragment( context: &Element, input: DOMString, can_gc: CanGc, ) -> impl Iterator<Item = Root<Dom<Node>>>

pub fn parse_html_script_input(document: &Document, url: ServoUrl)

pub fn parse_xml_document( document: &Document, input: Option<DOMString>, url: ServoUrl, can_gc: CanGc, )

pub fn script_nesting_level(&self) -> usize

pub fn is_script_created(&self) -> bool

pub fn resume_with_pending_parsing_blocking_script( &self, script: &HTMLScriptElement, result: Result<ScriptOrigin, NoTrace<NetworkError>>, can_gc: CanGc, )

Corresponds to the latter part of the “Otherwise” branch of the ‘An end tag whose tag name is “script”’ of https://html.spec.whatwg.org/multipage/#parsing-main-incdata

This first moves everything from the script input to the beginning of the network input, effectively resetting the insertion point to just before the next character to be consumed.

    | ... script input ... network input ...
    ^
    insertion point

pub fn can_write(&self) -> bool

pub fn write(&self, text: Vec<DOMString>, can_gc: CanGc)

Steps 6-8 of https://html.spec.whatwg.org/multipage/#document.write()

pub fn close(&self, can_gc: CanGc)

pub fn abort(&self, can_gc: CanGc)

pub fn is_active(&self) -> bool

fn new_inherited( document: &Document, tokenizer: Tokenizer, kind: ParserKind, ) -> Self

fn new( document: &Document, tokenizer: Tokenizer, kind: ParserKind, ) -> Root<Dom<Self>>

fn push_tendril_input_chunk(&self, chunk: StrTendril)

fn push_bytes_input_chunk(&self, chunk: Vec<u8>)

fn push_string_input_chunk(&self, chunk: String)

fn parse_sync(&self, can_gc: CanGc)

fn do_parse_sync(&self, can_gc: CanGc)

fn parse_complete_string_chunk(&self, input: String, can_gc: CanGc)

fn parse_bytes_chunk(&self, input: Vec<u8>, can_gc: CanGc)

fn tokenize<F>(&self, feed: F, can_gc: CanGc)

where F: Fn(&Tokenizer) -> TokenizerResult<Root<Dom<HTMLScriptElement>>>,

fn finish(&self, can_gc: CanGc)

Trait Implementations

impl DomObject for ServoParser

fn reflector(&self) -> &Reflector

Returns the receiver’s reflector.

fn global(&self) -> Root<Dom<GlobalScope>>

where Self: Sized,

Returns the global scope of the realm that the DomObject was created in.

impl DomObjectWrap for ServoParser

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ServoParserBinding::ServoParser_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::servoparser::ServoParser>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::servoparser::ServoParser>>}

Function pointer to the general wrap function type

impl HasParent for ServoParser

fn as_parent(&self) -> &Reflector

This is used in a type assertion to ensure that the source and webidls agree as to what the parent type is

type Parent = Reflector

impl IDLInterface for ServoParser

fn derives(class: &'static DOMClass) -> bool

Returns whether the given DOM class derives that interface.

impl MallocSizeOf for ServoParser

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl MutDomObject for ServoParser

unsafe fn init_reflector(&self, obj: *mut JSObject)

Initializes the Reflector

impl PartialEq for ServoParser

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToJSValConvertible for ServoParser

unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue<'_>)

Convert self to a JSVal. JSAPI failure causes a panic.

impl Traceable for ServoParser

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

impl Eq for ServoParser