Reenable optimization on XMLHttpRequest's receive-as-blob functionality

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 153 matching lines @@
     return xmlHttpRequest.release();
 }
 
 XMLHttpRequest::XMLHttpRequest(ExecutionContext* context, PassRefPtr<SecurityOrigin> securityOrigin)
     : ActiveDOMObject(context)
     , m_async(true)
     , m_includeCredentials(false)
     , m_timeoutMilliseconds(0)
     , m_state(UNSENT)
     , m_createdDocument(false)
+    , m_downloadedBlobLength(0)
     , m_error(false)
     , m_uploadEventsAllowed(true)
     , m_uploadComplete(false)
     , m_sameOriginRequest(true)
     , m_receivedLength(0)
     , m_lastSendLineNumber(0)
     , m_exceptionCode(0)
     , m_progressEventThrottle(this)
     , m_responseTypeCode(ResponseTypeDefault)
     , m_dropProtectionRunner(this, &XMLHttpRequest::dropProtection)
@@ skipping 85 matching lines @@
         }
         m_createdDocument = true;
     }
 
     return m_responseDocument.get();
 }
 
 Blob* XMLHttpRequest::responseBlob()
 {
     ASSERT(m_responseTypeCode == ResponseTypeBlob);
+    ASSERT(!m_binaryResponseBuilder.get());
 
     // We always return null before DONE.
     if (m_error || m_state != DONE)
         return 0;
 
     if (!m_responseBlob) {
-        // FIXME: Once RedirectToFileResourceHandler is fixed in Chromium,
-        // re-enable download-to-file optimization introduced by Blink revision
-        // 163141.
+        // When responseType is set to "blob", we redirect the downloaded data
+        // to a file-handle directly in the browser process. We get the
+        // file-path from the ResourceResponse directly instead of copying the
+        // bytes between the browser and the renderer.
         OwnPtr<BlobData> blobData = BlobData::create();
-        size_t size = 0;
-        if (m_binaryResponseBuilder.get() && m_binaryResponseBuilder->size() > 0) {
-            RefPtr<RawData> rawData = RawData::create();
-            size = m_binaryResponseBuilder->size();
-            rawData->mutableData()->append(m_binaryResponseBuilder->data(), size);
-            blobData->appendData(rawData, 0, BlobDataItem::toEndOfFile);
+        String filePath = m_response.downloadedFilePath();
+        // If we errored out or got no data, we still return a blob, just an
+        // empty one.
+        if (!filePath.isEmpty() && m_downloadedBlobLength) {
+            blobData->appendFile(filePath);
             blobData->setContentType(responseMIMEType()); // responseMIMEType defaults to text/xml which may be incorrect.
-            m_binaryResponseBuilder.clear();
         }
-        m_responseBlob = Blob::create(BlobDataHandle::create(blobData.release(), size));
+        m_responseBlob = Blob::create(BlobDataHandle::create(blobData.release(), m_downloadedBlobLength));
     }
 
     return m_responseBlob.get();
 }
 
 ArrayBuffer* XMLHttpRequest::responseArrayBuffer()
 {
     ASSERT(m_responseTypeCode == ResponseTypeArrayBuffer);
 
     if (m_error || m_state != DONE)
@@ skipping 538 matching lines @@
     options.contentSecurityPolicyEnforcement = ContentSecurityPolicy::shouldBypassMainWorld(&executionContext) ? DoNotEnforceContentSecurityPolicy : EnforceConnectSrcDirective;
     options.timeoutMilliseconds = m_timeoutMilliseconds;
 
     ResourceLoaderOptions resourceLoaderOptions;
     resourceLoaderOptions.allowCredentials = (m_sameOriginRequest || m_includeCredentials) ? AllowStoredCredentials : DoNotAllowStoredCredentials;
     resourceLoaderOptions.credentialsRequested = m_includeCredentials ? ClientRequestedCredentials : ClientDidNotRequestCredentials;
     resourceLoaderOptions.securityOrigin = securityOrigin();
     // TODO(tsepez): Specify TreatAsActiveContent per http://crbug.com/305303.
     resourceLoaderOptions.mixedContentBlockingTreatment = TreatAsPassiveContent;
 
+    // When responseType is set to "blob", we redirect the downloaded data to a
+    // file-handle directly.
+    if (responseTypeCode() == ResponseTypeBlob) {
+        request.setDownloadToFile(true);
+        resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
+    }
+
     m_exceptionCode = 0;
     m_error = false;
 
     if (m_async) {
         if (m_upload)
             request.setReportUploadProgress(true);
 
         // ThreadableLoader::create can return null here, for example if we're no longer attached to a page.
         // This is true while running onunload handlers.
         // FIXME: Maybe we need to be able to send XMLHttpRequests from onunload, <http://bugs.webkit.org/show_bug.cgi?id=10904>.
@@ skipping 103 matching lines @@
     m_receivedLength = 0;
 
     m_response = ResourceResponse();
 
     m_responseText.clear();
 
     m_createdDocument = false;
     m_responseDocument = nullptr;
 
     m_responseBlob = nullptr;
+    m_downloadedBlobLength = 0;
 
     m_responseStream = nullptr;
 
     // These variables may referred by the response accessors. So, we can clear
     // this only when we clear the response holder variables above.
     m_binaryResponseBuilder.clear();
     m_responseArrayBuffer.clear();
 }
 
 void XMLHttpRequest::clearRequest()
@@ skipping 317 matching lines @@
         m_response.setHTTPHeaderField("Content-Type", m_mimeTypeOverride);
         m_responseEncoding = extractCharsetFromMediaType(m_mimeTypeOverride);
     }
 
     if (m_responseEncoding.isEmpty())
         m_responseEncoding = response.textEncodingName();
 }
 
 void XMLHttpRequest::didReceiveData(const char* data, int len)
 {
+    ASSERT(m_responseTypeCode != ResponseTypeBlob);
+
     if (m_error)
         return;
 
     if (m_state < HEADERS_RECEIVED)
         changeState(HEADERS_RECEIVED);
 
     bool useDecoder = m_responseTypeCode == ResponseTypeDefault || m_responseTypeCode == ResponseTypeText || m_responseTypeCode == ResponseTypeJSON || m_responseTypeCode == ResponseTypeDocument;
 
     if (useDecoder && !m_decoder) {
         if (m_responseTypeCode == ResponseTypeJSON)
@@ skipping 12 matching lines @@
     }
 
     if (!len)
         return;
 
     if (len == -1)
         len = strlen(data);
 
     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) {
         // 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(executionContext(), responseMIMEType());
         m_responseStream->addData(data, len);
     }
 
     if (m_error)
         return;
 
     trackProgress(len);
 }
 
+void XMLHttpRequest::didDownloadData(int dataLength)
+{
+    ASSERT(m_responseTypeCode == ResponseTypeBlob);
+
+    if (m_error)
+        return;
+
+    if (m_state < HEADERS_RECEIVED)
+        changeState(HEADERS_RECEIVED);
+
+    if (!dataLength)
+        return;
+
+    // readystatechange event handler may do something to put this XHR in error
+    // state. We need to check m_error again here.
+    if (m_error)
+        return;
+
+    m_downloadedBlobLength += dataLength;
+
+    trackProgress(dataLength);
+}
+
 void XMLHttpRequest::handleDidTimeout()
 {
     WTF_LOG(Network, "XMLHttpRequest %p handleDidTimeout()", this);
 
     // internalAbort() calls dropProtection(), which may release the last reference.
     RefPtrWillBeRawPtr<XMLHttpRequest> protect(this);
 
     // Response is cleared next, save needed progress event data.
     long long expectedLength = m_response.expectedContentLength();
     long long receivedLength = m_receivedLength;
@@ skipping 40 matching lines @@
 {
     visitor->trace(m_responseBlob);
     visitor->trace(m_responseStream);
     visitor->trace(m_responseDocument);
     visitor->trace(m_progressEventThrottle);
     visitor->trace(m_upload);
     XMLHttpRequestEventTarget::trace(visitor);
 }
 
 } // namespace WebCore