Changeset 144000 in webkit

Timestamp:

Feb 25, 2013 6:36:18 PM (11 years ago)

Author:

abarth@webkit.org

Message:

Threaded HTML parser should pass fast/parser/iframe-sets-parent-to-javascript-url.html
​https://bugs.webkit.org/show_bug.cgi?id=110637

Reviewed by Eric Seidel.

With the main thread parser, we always parse the first chunk of content
returned as the result of evaluating a JavaScript URL synchronously. In
particular, if the first chunk has an inline script, we'll execute it
synchronously.

Previous to this patch, the threaded parser would always parse this
content asynchronously. It's conceivable that there could be some
content relying on the synchronous behavior, so this patch introduces
the notion of "pinning" a parser to the main thread and uses that
concept to force the result of JavaScript URLs to be parsed on the main
thread (which is probably desirable anyway because they're likely to be
quite short).

This patch fixes fast/parser/iframe-sets-parent-to-javascript-url.html
and fast/dom/javascript-url-crash-function.html with the threaded
parser with --enable-threaded-html-parser.

• dom/DocumentParser.h:

(WebCore::DocumentParser::pinToMainThread):
(DocumentParser):

• html/parser/HTMLDocumentParser.cpp:

(WebCore::HTMLDocumentParser::HTMLDocumentParser):
(WebCore):
(WebCore::HTMLDocumentParser::pinToMainThread):

• html/parser/HTMLDocumentParser.h:

(HTMLDocumentParser):
(WebCore::HTMLDocumentParser::shouldUseThreading):

• loader/DocumentWriter.cpp:

(WebCore::DocumentWriter::replaceDocument):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• dom/DocumentParser.h (modified) (1 diff)
• html/parser/HTMLDocumentParser.cpp (modified) (3 diffs)
• html/parser/HTMLDocumentParser.h (modified) (4 diffs)
• loader/DocumentWriter.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-02-25  Adam Barth  <abarth@webkit.org>
+
+        Threaded HTML parser should pass fast/parser/iframe-sets-parent-to-javascript-url.html
+        https://bugs.webkit.org/show_bug.cgi?id=110637
+
+        Reviewed by Eric Seidel.
+
+        With the main thread parser, we always parse the first chunk of content
+        returned as the result of evaluating a JavaScript URL synchronously. In
+        particular, if the first chunk has an inline script, we'll execute it
+        synchronously.
+
+        Previous to this patch, the threaded parser would always parse this
+        content asynchronously. It's conceivable that there could be some
+        content relying on the synchronous behavior, so this patch introduces
+        the notion of "pinning" a parser to the main thread and uses that
+        concept to force the result of JavaScript URLs to be parsed on the main
+        thread (which is probably desirable anyway because they're likely to be
+        quite short).
+
+        This patch fixes fast/parser/iframe-sets-parent-to-javascript-url.html
+        and fast/dom/javascript-url-crash-function.html with the threaded
+        parser with --enable-threaded-html-parser.
+
+        * dom/DocumentParser.h:
+        (WebCore::DocumentParser::pinToMainThread):
+        (DocumentParser):
+        * html/parser/HTMLDocumentParser.cpp:
+        (WebCore::HTMLDocumentParser::HTMLDocumentParser):
+        (WebCore):
+        (WebCore::HTMLDocumentParser::pinToMainThread):
+        * html/parser/HTMLDocumentParser.h:
+        (HTMLDocumentParser):
+        (WebCore::HTMLDocumentParser::shouldUseThreading):
+        * loader/DocumentWriter.cpp:
+        (WebCore::DocumentWriter::replaceDocument):
+
 2013-02-25  Jessie Berlin  <jberlin@apple.com>
 

trunk/Source/WebCore/dom/DocumentParser.h

@@ -49 +49 @@
     virtual void appendBytes(DocumentWriter*, const char* bytes, size_t length) = 0;
     virtual void flush(DocumentWriter*) = 0;
+
+    virtual void pinToMainThread() { }
 
     // FIXME: append() should be private, but DocumentWriter::replaceDocument

trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp

@@ -90 +90 @@
 #endif
     , m_preloader(adoptPtr(new HTMLResourcePreloader(document)))
+    , m_isPinnedToMainThread(false)
     , m_endWasDelayed(false)
     , m_haveBackgroundParser(false)
@@ -109 +110 @@
     , m_weakFactory(this)
 #endif
+    , m_isPinnedToMainThread(true)
     , m_endWasDelayed(false)
     , m_haveBackgroundParser(false)
@@ -126 +128 @@
     ASSERT(!m_haveBackgroundParser);
 }
+
+#if ENABLE(THREADED_HTML_PARSER)
+void HTMLDocumentParser::pinToMainThread()
+{
+    ASSERT(!m_haveBackgroundParser);
+    ASSERT(!m_isPinnedToMainThread);
+    m_isPinnedToMainThread = true;
+    if (!m_tokenizer) {
+        ASSERT(!m_token);
+        m_token = adoptPtr(new HTMLToken);
+        m_tokenizer = HTMLTokenizer::create(m_options);
+    }
+}
+#endif
 
 void HTMLDocumentParser::detach()

trunk/Source/WebCore/html/parser/HTMLDocumentParser.h

@@ -97 +97 @@
 
 protected:
-    virtual void insert(const SegmentedString&);
-    virtual void append(const SegmentedString&);
-    virtual void finish();
+    virtual void insert(const SegmentedString&) OVERRIDE;
+    virtual void append(const SegmentedString&) OVERRIDE;
+    virtual void finish() OVERRIDE;
 
     HTMLDocumentParser(HTMLDocument*, bool reportErrors);
@@ -115 +115 @@
 
     // DocumentParser
-    virtual void detach();
-    virtual bool hasInsertionPoint();
-    virtual bool processingData() const;
-    virtual void prepareToStopParsing();
-    virtual void stopParsing();
-    virtual bool isWaitingForScripts() const;
-    virtual bool isExecutingScript() const;
-    virtual void executeScriptsWaitingForStylesheets();
+#if ENABLE(THREADED_HTML_PARSER)
+    virtual void pinToMainThread() OVERRIDE;
+#endif
+    virtual void detach() OVERRIDE;
+    virtual bool hasInsertionPoint() OVERRIDE;
+    virtual bool processingData() const OVERRIDE;
+    virtual void prepareToStopParsing() OVERRIDE;
+    virtual void stopParsing() OVERRIDE;
+    virtual bool isWaitingForScripts() const OVERRIDE;
+    virtual bool isExecutingScript() const OVERRIDE;
+    virtual void executeScriptsWaitingForStylesheets() OVERRIDE;
 
     // HTMLScriptRunnerHost
-    virtual void watchForLoad(CachedResource*);
-    virtual void stopWatchingForLoad(CachedResource*);
+    virtual void watchForLoad(CachedResource*) OVERRIDE;
+    virtual void stopWatchingForLoad(CachedResource*) OVERRIDE;
     virtual HTMLInputStream& inputStream() { return m_input; }
     virtual bool hasPreloadScanner() const { return m_preloadScanner.get() && !shouldUseThreading(); }
-    virtual void appendCurrentInputStreamToPreloadScannerAndScan();
+    virtual void appendCurrentInputStreamToPreloadScannerAndScan() OVERRIDE;
 
     // CachedResourceClient
@@ -165 +168 @@
     void end();
 
-    bool shouldUseThreading() const { return m_options.useThreading && !isParsingFragment(); }
+    bool shouldUseThreading() const { return m_options.useThreading && !m_isPinnedToMainThread; }
 
     bool isParsingFragment() const;
@@ -197 +200 @@
     OwnPtr<HTMLResourcePreloader> m_preloader;
 
+    bool m_isPinnedToMainThread;
     bool m_endWasDelayed;
     bool m_haveBackgroundParser;

trunk/Source/WebCore/loader/DocumentWriter.cpp

@@ -79 +79 @@
         // FIXME: This should call DocumentParser::appendBytes instead of append
         // to support RawDataDocumentParsers.
-        if (DocumentParser* parser = m_frame->document()->parser())
+        if (DocumentParser* parser = m_frame->document()->parser()) {
+            parser->pinToMainThread();
             parser->append(source);
+        }
     }