Make XHR use background HTML parser

This patch enables background html parser for documents with no frames,
which are XMLHttpRequest response documents. HTML imports and
inspector/DOMPatchSupport will still to use the synchronous mode as the
current code expect the change to happen synchronously.

Before this change, XMLHttpRequest immediately set its state to DONE after
receiving the last data. After this change, XMLHttpRequest will wait for
|Document::finishedParsing| before changing its state to DONE if it has
responseType == "document". This is needed because |DocumentParser::finish()|
do not synchronously give the complete document, but we have to wait until all
tokens from the background parser is processed.

BUG=409461

Review URL: https://codereview.chromium.org/521363002

git-svn-id: svn://svn.chromium.org/blink/trunk@181684 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/html/parser/HTMLDocumentParser.cpp

@@ -744,8 +744,10 @@ void HTMLDocumentParser::startBackgroundParser()
     m_backgroundParser = WeakPtr<BackgroundHTMLParser>(reference);
 
     // TODO(oysteine): Disabled due to crbug.com/398076 until a full fix can be implemented.
-    if (RuntimeEnabledFeatures::threadedParserDataReceiverEnabled())
-        document()->loader()->attachThreadedDataReceiver(adoptPtr(new ParserDataReceiver(m_backgroundParser)));
+    if (RuntimeEnabledFeatures::threadedParserDataReceiverEnabled()) {
+        if (DocumentLoader* loader = document()->loader())
+            loader->attachThreadedDataReceiver(adoptPtr(new ParserDataReceiver(m_backgroundParser)));
+    }
 
     OwnPtr<BackgroundHTMLParser::Configuration> config = adoptPtr(new BackgroundHTMLParser::Configuration);
     config->options = m_options;

third_party/WebKit/Source/core/html/parser/HTMLParserOptions.cpp

@@ -40,16 +40,15 @@ HTMLParserOptions::HTMLParserOptions(Document* document)
     scriptEnabled = frame && frame->script().canExecuteScripts(NotAboutToExecuteScript);
     pluginsEnabled = frame && frame->loader().allowPlugins(NotAboutToInstantiatePlugin);
 
-    // We force the main-thread parser for two cases:
+    // We force the main-thread parser for three cases:
     // - about:blank and javascript (which uses about:blank) for compatibility
     //   with historical synchronous loading/parsing behavior.
-    // - instances where the Document has no Frame (this happens sometimes for
-    //   HTML imports, and possibly other cases).
-    // FIXME: We want to use the threaded parser for XHRs (where there is no
-    // frame) so the second case should go away eventually.
+    // - HTML imports (FIXME: enable off-thread parser for this case)
+    // - inspector/DOMPatchSupport replacing the whole document.
+    //   (DOMPatchSupport calls in |DocumentParser::pinToMainThread()| for this case)
     // FIXME: Gecko does not load javascript: urls synchronously, why do we?
     // See LayoutTests/loader/iframe-sync-loads.html
-    useThreading = document && document->frame() && !document->url().isAboutBlankURL();
+    useThreading = document && !document->importsController() && !document->url().isAboutBlankURL();
 }
 
 }

third_party/WebKit/Source/core/inspector/DOMPatchSupport.cpp

@@ -97,6 +97,7 @@ void DOMPatchSupport::patchDocument(const String& markup)
         parser = HTMLDocumentParser::create(toHTMLDocument(*newDocument), false);
     else
         parser = XMLDocumentParser::create(*newDocument, 0);
+    parser->pinToMainThread();
     parser->insert(markup); // Use insert() so that the parser will not yield.
     parser->finish();
     parser->detach();

third_party/WebKit/Source/core/xml/XMLHttpRequest.cpp

@@ -144,6 +144,7 @@ PassRefPtrWillBeRawPtr<XMLHttpRequest> XMLHttpRequest::create(ExecutionContext*
 XMLHttpRequest::XMLHttpRequest(ExecutionContext* context, PassRefPtr<SecurityOrigin> securityOrigin)
     : ActiveDOMObject(context)
     , m_timeoutMilliseconds(0)
+    , m_loaderIdentifier(0)
     , m_state(UNSENT)
     , m_downloadedBlobLength(0)
     , m_receivedLength(0)
@@ -912,6 +913,7 @@ void XMLHttpRequest::clearVariablesForLoading()
     m_decoder.clear();
 
     if (m_responseDocumentParser) {
+        m_responseDocumentParser->removeClient(this);
 #if !ENABLE(OILPAN)
         m_responseDocumentParser->detach();
 #endif
@@ -1280,19 +1282,20 @@ void XMLHttpRequest::didFinishLoading(unsigned long identifier, double)
     if (m_state < HEADERS_RECEIVED)
         changeState(HEADERS_RECEIVED);
 
+    m_loaderIdentifier = identifier;
+
     if (m_responseDocumentParser) {
+        // |DocumentParser::finish()| tells the parser that we have reached end of the data.
+        // When using |HTMLDocumentParser|, which works asynchronously, we do not have the
+        // complete document just after the |DocumentParser::finish()| call.
+        // Wait for the parser to call us back in |notifyParserStopped| to progress state.
         m_responseDocumentParser->finish();
-        m_responseDocumentParser = nullptr;
-
-        m_responseDocument->implicitClose();
-
-        if (!m_responseDocument->wellFormed())
-            m_responseDocument = nullptr;
+        ASSERT(m_responseDocument);
+        return;
+    }
 
-        m_parsedResponse = true;
-    } else if (m_decoder) {
+    if (m_decoder)
         m_responseText = m_responseText.concatenateWith(m_decoder->flush());
-    }
 
     if (m_responseLegacyStream)
         m_responseLegacyStream->finalize();
@@ -1301,11 +1304,40 @@ void XMLHttpRequest::didFinishLoading(unsigned long identifier, double)
         m_responseStream->close();
 
     clearVariablesForLoading();
+    endLoading();
+}
+
+void XMLHttpRequest::notifyParserStopped()
+{
+    // This should only be called when response document is parsed asynchronously.
+    ASSERT(m_responseDocumentParser);
+    ASSERT(!m_responseDocumentParser->isParsing());
+    ASSERT(!m_responseLegacyStream);
+    ASSERT(!m_responseStream);
+
+    // Do nothing if we are called from |internalAbort()|.
+    if (m_error)
+        return;
+
+    clearVariablesForLoading();
+
+    m_responseDocument->implicitClose();
 
-    InspectorInstrumentation::didFinishXHRLoading(executionContext(), this, this, identifier, m_responseText, m_method, m_url, m_lastSendURL, m_lastSendLineNumber);
+    if (!m_responseDocument->wellFormed())
+        m_responseDocument = nullptr;
+
+    m_parsedResponse = true;
+
+    endLoading();
+}
+
+void XMLHttpRequest::endLoading()
+{
+    InspectorInstrumentation::didFinishXHRLoading(executionContext(), this, this, m_loaderIdentifier, m_responseText, m_method, m_url, m_lastSendURL, m_lastSendLineNumber);
 
     if (m_loader)
         m_loader = nullptr;
+    m_loaderIdentifier = 0;
 
     changeState(DONE);
 }
@@ -1350,6 +1382,7 @@ void XMLHttpRequest::parseDocumentChunk(const char* data, int len)
             return;
 
         m_responseDocumentParser = m_responseDocument->implicitOpen();
+        m_responseDocumentParser->addClient(this);
     }
     ASSERT(m_responseDocumentParser);
 

third_party/WebKit/Source/core/xml/XMLHttpRequest.h

@@ -24,6 +24,7 @@
 
 #include "bindings/core/v8/ScriptString.h"
 #include "core/dom/ActiveDOMObject.h"
+#include "core/dom/DocumentParserClient.h"
 #include "core/events/EventListener.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/streams/ReadableStreamImpl.h"
@@ -58,6 +59,7 @@ class XMLHttpRequest FINAL
     : public RefCountedWillBeGarbageCollectedFinalized<XMLHttpRequest>
     , public XMLHttpRequestEventTarget
     , private ThreadableLoaderClient
+    , public DocumentParserClient
     , public ActiveDOMObject {
     DEFINE_WRAPPERTYPEINFO();
     REFCOUNTED_EVENT_TARGET(XMLHttpRequest);
@@ -166,6 +168,11 @@ private:
     virtual void didFail(const ResourceError&) OVERRIDE;
     virtual void didFailRedirectCheck() OVERRIDE;
 
+    // DocumentParserClient
+    virtual void notifyParserStopped() OVERRIDE;
+
+    void endLoading();
+
     // Returns the MIME type part of m_mimeTypeOverride if present and
     // successfully parsed, or returns one of the "Content-Type" header value
     // of the received response.
@@ -244,6 +251,7 @@ private:
     PersistentWillBeMember<UnderlyingSource> m_streamSource;
 
     RefPtr<ThreadableLoader> m_loader;
+    unsigned long m_loaderIdentifier;
     State m_state;
 
     ResourceResponse m_response;