Make XHR use the background HTML parser

Source/core/xml/XMLHttpRequest.cpp

 /*
  *  Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
  *  Copyright (C) 2012 Intel Corporation
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 126 matching lines @@
 {
     RefPtrWillBeRawPtr<XMLHttpRequest> xmlHttpRequest = adoptRefWillBeNoop(new XMLHttpRequest(context, securityOrigin));
     xmlHttpRequest->suspendIfNeeded();
 
     return xmlHttpRequest.release();
 }
 
 XMLHttpRequest::XMLHttpRequest(ExecutionContext* context, PassRefPtr<SecurityOrigin> securityOrigin)
     : ActiveDOMObject(context)
     , m_timeoutMilliseconds(0)
+    , m_loaderIdentifier(0)
     , m_state(UNSENT)
     , m_downloadedBlobLength(0)
     , m_receivedLength(0)
     , m_lastSendLineNumber(0)
     , m_exceptionCode(0)
     , m_progressEventThrottle(this)
     , m_responseTypeCode(ResponseTypeDefault)
     , m_securityOrigin(securityOrigin)
     , m_async(true)
     , m_includeCredentials(false)
@@ skipping 748 matching lines @@
         handleRequestError(0, EventTypeNames::abort, receivedLength, expectedLength);
     }
     m_state = UNSENT;
 }
 
 void XMLHttpRequest::clearVariablesForLoading()
 {
     m_decoder.clear();
 
     if (m_responseDocumentParser) {
+        m_responseDocumentParser->removeClient(this);
 #if !ENABLE(OILPAN)
         m_responseDocumentParser->detach();
 #endif
         m_responseDocumentParser = nullptr;
     }
 
     m_finalResponseCharset = String();
 }
 
 bool XMLHttpRequest::internalAbort()
 {
     m_error = true;
 
     if (m_responseDocumentParser && !m_responseDocumentParser->isStopped())

[tyoshino (SeeGerritForStatus), 2014/09/10 06:46:36]

how about calling
m_responseDocumentParser->removeClient(this);
here?

[kouhei (in TOK), 2014/09/10 20:50:42]

Would you elabolate on it? I want to know why you prefer it.
I thought addClient(this) at where parser created, and removeClient(this) at
where parser ref is disposed is simple.

[tyoshino (SeeGerritForStatus), 2014/09/11 02:58:00]

I saw "notifyParserStopped" checking m_error and if it's true becomes no-op. So,
I guessed we could just prevent it from being invoked by calling removeClient.
but right. We continue to use m_responseDocumentParser. So, it's not the right
thing to do. Never mind. Thanks

         m_responseDocumentParser->stopParsing();
 
     clearVariablesForLoading();
 
     InspectorInstrumentation::didFailXHRLoading(executionContext(), this, this);
 
     if (m_responseLegacyStream && m_state != DONE)
         m_responseLegacyStream->abort();
 
     if (m_responseStream) {
@@ skipping 97 matching lines @@
     handleRequestError(NetworkError, EventTypeNames::error, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::handleDidCancel()
 {
     WTF_LOG(Network, "XMLHttpRequest %p handleDidCancel()", this);
 
     // Response is cleared next, save needed progress event data.
     long long expectedLength = m_response.expectedContentLength();
     long long receivedLength = m_receivedLength;
 

[tyoshino (SeeGerritForStatus), 2014/09/10 06:46:36]

if the loader is cancelled by someone else than the client, we reach here. we're
currently not calling internalAbort(). So, we clears m_responseDocument but not
m_responseDocumentParser until open() calls internalAbort().

I'm going to add internalAbort() call in
https://codereview.chromium.org/490083002/.

[kouhei (in TOK), 2014/09/10 20:50:42]

Hmm. I guess you mean that handleDidFailGeneric doesn't call
clearVariablesForLoading. This is indeed weird. your patch sgtm

[tyoshino (SeeGerritForStatus), 2014/09/11 03:41:32]

Right!

     handleDidFailGeneric();
     handleRequestError(AbortError, EventTypeNames::abort, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type, long long receivedLength, long long expectedLength)
 {
     WTF_LOG(Network, "XMLHttpRequest %p handleRequestError()", this);
 
     // The request error steps for event 'type' and exception 'exceptionCode'.
 
@@ skipping 216 matching lines @@
 void XMLHttpRequest::didFinishLoading(unsigned long identifier, double)
 {
     WTF_LOG(Network, "XMLHttpRequest %p didFinishLoading(%lu)", this, identifier);
 
     if (m_error)
         return;
 
     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;
+        ASSERT(m_responseDocument);
+        return;
+    }
 
-        m_responseDocument->implicitClose();
-
-        if (!m_responseDocument->wellFormed())
-            m_responseDocument = nullptr;
-
-        m_parsedResponse = true;
-    } else if (m_decoder) {
+    if (m_decoder)
         m_responseText = m_responseText.concatenateWith(m_decoder->flush());
-    }
 
     if (m_responseLegacyStream)
         m_responseLegacyStream->finalize();
 
     if (m_responseStream)
         m_responseStream->close();
 
     clearVariablesForLoading();
+    endLoading();
+}
 
-    InspectorInstrumentation::didFinishXHRLoading(executionContext(), this, this, identifier, m_responseText, m_method, m_url, m_lastSendURL, m_lastSendLineNumber);
+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();
+
+    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);
 }
 
 void XMLHttpRequest::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     WTF_LOG(Network, "XMLHttpRequest %p didSendData(%llu, %llu)", this, bytesSent, totalBytesToBeSent);
 
     if (!m_upload)
         return;
@@ skipping 24 matching lines @@
 
 void XMLHttpRequest::parseDocumentChunk(const char* data, int len)
 {
     if (!m_responseDocumentParser) {
         ASSERT(!m_responseDocument);
         initResponseDocument();
         if (!m_responseDocument)
             return;
 
         m_responseDocumentParser = m_responseDocument->implicitOpen();
+        m_responseDocumentParser->addClient(this);
     }
     ASSERT(m_responseDocumentParser);
 
     if (m_responseDocumentParser->needsDecoder())
         m_responseDocumentParser->setDecoder(createDecoder());
 
     m_responseDocumentParser->appendBytes(data, len);
 }
 
 PassOwnPtr<TextResourceDecoder> XMLHttpRequest::createDecoder() const
@@ skipping 151 matching lines @@
     visitor->trace(m_responseStream);
     visitor->trace(m_streamSource);
     visitor->trace(m_responseDocument);
     visitor->trace(m_responseDocumentParser);
     visitor->trace(m_progressEventThrottle);
     visitor->trace(m_upload);
     XMLHttpRequestEventTarget::trace(visitor);
 }
 
 } // namespace blink