Make ServoParser::pending_input hold onto a BufferQueue

components/script/dom/servoparser/html.rs

@@ -34,22 +34,19 @@ use js::jsapi::JSTracer;
 use servo_url::ServoUrl;
 use std::borrow::Cow;
 use std::io::{self, Write};
-use super::{FragmentContext, Sink};
 
 #[derive(HeapSizeOf, JSTraceable)]
 #[must_root]
 pub struct Tokenizer {
     #[ignore_heap_size_of = "Defined in html5ever"]
     inner: HtmlTokenizer<TreeBuilder<JS<Node>, Sink>>,
-    #[ignore_heap_size_of = "Defined in html5ever"]
-    input_buffer: BufferQueue,
 }
 
 impl Tokenizer {
     pub fn new(
             document: &Document,
             url: ServoUrl,
-            fragment_context: Option<FragmentContext>)
+            fragment_context: Option<super::FragmentContext>)
             -> Self {
         let sink = Sink {
             base_url: url,
@@ -80,27 +77,17 @@ impl Tokenizer {
 
         Tokenizer {
             inner: inner,
-            input_buffer: BufferQueue::new(),
         }
     }
 
-    pub fn feed(&mut self, input: String) {
-        self.input_buffer.push_back(input.into());
-        self.run();
-    }
-
-    #[allow(unrooted_must_root)]
-    pub fn run(&mut self) {
-        while let TokenizerResult::Script(script) = self.inner.feed(&mut self.input_buffer) {
-            let script = Root::from_ref(script.downcast::<HTMLScriptElement>().unwrap());
-            if !script.prepare() {
-                break;
-            }
+    pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), Root<HTMLScriptElement>> {
+        match self.inner.feed(input) {
+            TokenizerResult::Done => Ok(()),
+            TokenizerResult::Script(script) => Err(Root::from_ref(script.downcast().unwrap())),
         }
     }
 
     pub fn end(&mut self) {
-        assert!(self.input_buffer.is_empty());
         self.inner.end();
     }
 
@@ -128,6 +115,13 @@ impl JSTraceable for HtmlTokenizer<TreeBuilder<JS<Node>, Sink>> {
     }
 }
 
+#[derive(JSTraceable, HeapSizeOf)]
+#[must_root]
+struct Sink {
+    base_url: ServoUrl,
+    document: JS<Document>,
+}
+
 impl<'a> TreeSink for Sink {
     type Output = Self;
     fn finish(self) -> Self { self }