Add Streams API support to XMLHttpRequest

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
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #include "config.h"
 #include "core/xml/XMLHttpRequest.h"
 
 #include "FetchInitiatorTypeNames.h"
+#include "RuntimeEnabledFeatures.h"
 #include "bindings/v8/ExceptionMessages.h"
 #include "bindings/v8/ExceptionState.h"
 #include "core/dom/ContextFeatures.h"
 #include "core/dom/DOMImplementation.h"
 #include "core/dom/Event.h"
 #include "core/dom/EventListener.h"
 #include "core/dom/EventNames.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/editing/markup.h"
 #include "core/fetch/TextResourceDecoder.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
+#include "core/fileapi/Stream.h"
 #include "core/html/DOMFormData.h"
 #include "core/html/HTMLDocument.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/CrossOriginAccessControl.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/page/ContentSecurityPolicy.h"
 #include "core/page/Settings.h"
 #include "core/platform/HistogramSupport.h"
 #include "core/platform/SharedBuffer.h"
 #include "core/platform/network/BlobData.h"
@@ skipping 262 matching lines @@
         return 0;
 
     if (!m_responseArrayBuffer.get() && m_binaryResponseBuilder.get() && m_binaryResponseBuilder->size() > 0) {
         m_responseArrayBuffer = m_binaryResponseBuilder->getAsArrayBuffer();
         m_binaryResponseBuilder.clear();
     }
 
     return m_responseArrayBuffer.get();
 }
 
+Stream* XMLHttpRequest::responseStream()
+{
+    ASSERT(m_responseTypeCode == ResponseTypeStream);
+
+    if (m_error || (m_state != LOADING && m_state != DONE))
+        return 0;
+
+    return m_responseStream.get();
+}
+
 void XMLHttpRequest::setTimeout(unsigned long timeout, ExceptionState& es)
 {
     // FIXME: Need to trigger or update the timeout Timer here, if needed. http://webkit.org/b/98156
     // XHR2 spec, 4.7.3. "This implies that the timeout attribute can be set while fetching is in progress. If that occurs it will still be measured relative to the start of fetching."
     if (scriptExecutionContext()->isDocument() && !m_async) {
         es.throwDOMException(InvalidAccessError, ExceptionMessages::failedToSet("timeout", "XMLHttpRequest", "timeouts cannot be set for synchronous requests made from a document."));
         return;
     }
     m_timeoutMilliseconds = timeout;
 }
 
 void XMLHttpRequest::setResponseType(const String& responseType, ExceptionState& es)
 {
     if (m_state >= LOADING) {
         es.throwDOMException(InvalidStateError, ExceptionMessages::failedToSet("responseType", "XMLHttpRequest", "the response type cannot be set if the object's state is LOADING or DONE."));
         return;
     }
 
     // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
     // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
     // We'll only disable this functionality for HTTP(S) requests since sync requests for local protocols
     // such as file: and data: still make sense to allow.
     if (!m_async && scriptExecutionContext()->isDocument() && m_url.protocolIsInHTTPFamily()) {
         es.throwDOMException(InvalidAccessError, ExceptionMessages::failedToSet("responseType", "XMLHttpRequest", "the response type can only be changed for asynchronous HTTP requests made from a document."));
         return;
     }
 
-    if (responseType == "")
+    if (responseType == "") {
         m_responseTypeCode = ResponseTypeDefault;
-    else if (responseType == "text")
+    } else if (responseType == "text") {
         m_responseTypeCode = ResponseTypeText;
-    else if (responseType == "json")
+    } else if (responseType == "json") {
         m_responseTypeCode = ResponseTypeJSON;
-    else if (responseType == "document")
+    } else if (responseType == "document") {
         m_responseTypeCode = ResponseTypeDocument;
-    else if (responseType == "blob")
+    } else if (responseType == "blob") {
         m_responseTypeCode = ResponseTypeBlob;
-    else if (responseType == "arraybuffer")
+    } else if (responseType == "arraybuffer") {
         m_responseTypeCode = ResponseTypeArrayBuffer;
-    else
+    } else if (responseType == "stream") {
+        if (RuntimeEnabledFeatures::streamEnabled())
+            m_responseTypeCode = ResponseTypeStream;
+        else
+            return;
+    } else {
         ASSERT_NOT_REACHED();
+    }
 }
 
 String XMLHttpRequest::responseType()
 {
     switch (m_responseTypeCode) {
     case ResponseTypeDefault:
         return "";
     case ResponseTypeText:
         return "text";
     case ResponseTypeJSON:
         return "json";
     case ResponseTypeDocument:
         return "document";
     case ResponseTypeBlob:
         return "blob";
     case ResponseTypeArrayBuffer:
         return "arraybuffer";
+    case ResponseTypeStream:
+        return "stream";
     }
     return "";
 }
 
 XMLHttpRequestUpload* XMLHttpRequest::upload()
 {
     if (!m_upload)
         m_upload = XMLHttpRequestUpload::create(this);
     return m_upload.get();
 }
@@ skipping 429 matching lines @@
 void XMLHttpRequest::internalAbort(DropProtection async)
 {
     m_error = true;
 
     // FIXME: when we add the support for multi-part XHR, we will have to think be careful with this initialization.
     m_receivedLength = 0;
     m_decoder = 0;
 
     InspectorInstrumentation::didFailXHRLoading(scriptExecutionContext(), this);
 
-    if (m_loader) {
-        m_loader->cancel();
-        m_loader = 0;
+    if (m_responseStream && m_state != DONE)
+        m_responseStream->abort();
 
-        if (async == DropProtectionAsync)
-            dropProtectionSoon();
-        else
-            dropProtection();
-    }
+    if (!m_loader)
+        return;
+
+    m_loader->cancel();
+    m_loader = 0;
+
+    if (async == DropProtectionAsync)
+        dropProtectionSoon();
+    else
+        dropProtection();
 }
 
 void XMLHttpRequest::clearResponse()
 {
     m_response = ResourceResponse();
     clearResponseBuffers();
 }
 
 void XMLHttpRequest::clearResponseBuffers()
 {
     m_responseText.clear();
     m_responseEncoding = String();
     m_createdDocument = false;
     m_responseDocument = 0;
     m_responseBlob = 0;
+    m_responseStream = 0;
     m_binaryResponseBuilder.clear();
     m_responseArrayBuffer.clear();
 }
 
 void XMLHttpRequest::clearRequest()
 {
     m_requestHeaders.clear();
     m_requestEntityBody = 0;
 }
 
@@ skipping 227 matching lines @@
 {
     if (m_error)
         return;
 
     if (m_state < HEADERS_RECEIVED)
         changeState(HEADERS_RECEIVED);
 
     if (m_decoder)
         m_responseText = m_responseText.concatenateWith(m_decoder->flush());
 
+    if (m_responseStream)
+        m_responseStream->finalize();
+
     InspectorInstrumentation::didFinishXHRLoading(scriptExecutionContext(), this, identifier, m_responseText, m_url, m_lastSendURL, m_lastSendLineNumber);
 
     // Prevent dropProtection releasing the last reference, and retain |this| until the end of this method.
     RefPtr<XMLHttpRequest> protect(this);
 
     if (m_loader) {
         m_loader = 0;
         dropProtection();
     }
 
@@ skipping 56 matching lines @@
         else
             m_decoder = TextResourceDecoder::create("text/plain", "UTF-8");
     }
 
     if (!len)
         return;
 
     if (len == -1)
         len = strlen(data);
 
-    if (useDecoder)
+    if (useDecoder) {
         m_responseText = m_responseText.concatenateWith(m_decoder->decode(data, len));
-    else if (m_responseTypeCode == ResponseTypeArrayBuffer || m_responseTypeCode == ResponseTypeBlob) {
+    } else if (m_responseTypeCode == ResponseTypeArrayBuffer || m_responseTypeCode == ResponseTypeBlob) {
         // Buffer binary data.
         if (!m_binaryResponseBuilder)
             m_binaryResponseBuilder = SharedBuffer::create();
         m_binaryResponseBuilder->append(data, len);
+    } else if (m_responseTypeCode == ResponseTypeStream) {
+        if (!m_responseStream)
+            m_responseStream = Stream::create(responseMIMEType());
+        m_responseStream->addData(data, len);
     }
 
     if (!m_error) {
         long long expectedLength = m_response.expectedContentLength();
         m_receivedLength += len;
 
         if (m_async) {
             bool lengthComputable = expectedLength > 0 && m_receivedLength <= expectedLength;
             unsigned long long total = lengthComputable ? expectedLength : 0;
             m_progressEventThrottle.dispatchProgressEvent(lengthComputable, m_receivedLength, total);
@@ skipping 65 matching lines @@
 {
     return eventNames().interfaceForXMLHttpRequest;
 }
 
 ScriptExecutionContext* XMLHttpRequest::scriptExecutionContext() const
 {
     return ActiveDOMObject::scriptExecutionContext();
 }
 
 } // namespace WebCore