Unify ServoHTMLParser and ServoXMLParser in ServoParser

components/script/dom/document.rs

@@ -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()
     }
 

components/script/dom/mod.rs

@@ -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;

components/script/dom/servohtmlparser.rs

@@ -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);
-    }
-}

components/script/dom/servoparser.rs

@@ -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);
+            }
+        }
+    }
 }

components/script/dom/servoxmlparser.rs

@@ -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);
-    }
-}

components/script/dom/webidls/ServoHTMLParser.webidl

@@ -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 {
-};

components/script/dom/webidls/ServoParser.webidl

@@ -6,5 +6,5 @@
 // web pages.
 
 [Exposed=(Window,Worker),
- Inline]
+ NoInterfaceObject]
 interface ServoParser {};

components/script/dom/webidls/ServoXMLParser.webidl

@@ -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 {
-};
-