Import Qt5x2 branch of QtWebkit for Qt 5.2

Importing a new snapshot of webkit.

Change-Id: I2d01ad12cdc8af8cb015387641120a9d7ea5f10c
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@digia.com>

1 files changed, 77 insertions, 3 deletions

diff --git a/Source/WebCore/fileapi/FileReaderLoader.cpp b/Source/WebCore/fileapi/FileReaderLoader.cpp
index f24cdc82f..77c05fe81 100644
--- a/Source/WebCore/fileapi/FileReaderLoader.cpp
+++ b/Source/WebCore/fileapi/FileReaderLoader.cpp
@@ -54,13 +54,19 @@ using namespace std;
 
 namespace WebCore {
 
+const int defaultBufferLength = 32768;
+
 FileReaderLoader::FileReaderLoader(ReadType readType, FileReaderLoaderClient* client)
     : m_readType(readType)
     , m_client(client)
     , m_isRawDataConverted(false)
     , m_stringResult("")
+    , m_variableLength(false)
     , m_bytesLoaded(0)
     , m_totalBytes(0)
+    , m_hasRange(false)
+    , m_rangeStart(0)
+    , m_rangeEnd(0)
     , m_errorCode(0)
 {
 }
@@ -85,6 +91,8 @@ void FileReaderLoader::start(ScriptExecutionContext* scriptExecutionContext, Blo
     // Construct and load the request.
     ResourceRequest request(m_urlForReading);
     request.setHTTPMethod("GET");
+    if (m_hasRange)
+        request.setHTTPHeaderField("Range", String::format("bytes=%d-%d", m_rangeStart, m_rangeEnd));
 
     ThreadableLoaderOptions options;
     options.sendLoadCallbacks = SendCallbacks;
@@ -133,6 +141,16 @@ void FileReaderLoader::didReceiveResponse(unsigned long, const ResourceResponse&
 
     unsigned long long length = response.expectedContentLength();
 
+    // A value larger than INT_MAX means that the content length wasn't
+    // specified, so the buffer will need to be dynamically grown.
+    if (length > INT_MAX) {
+        m_variableLength = true;
+        if (m_hasRange)
+            length = 1 + m_rangeEnd - m_rangeStart;
+        else
+            length = defaultBufferLength;
+    }
+
     // Check that we can cast to unsigned since we have to do
     // so to call ArrayBuffer's create function.
     // FIXME: Support reading more than the current size limit of ArrayBuffer.
@@ -166,8 +184,25 @@ void FileReaderLoader::didReceiveData(const char* data, int dataLength)
 
     int length = dataLength;
     unsigned remainingBufferSpace = m_totalBytes - m_bytesLoaded;
-    if (length > static_cast<long long>(remainingBufferSpace))
-        length = static_cast<int>(remainingBufferSpace);
+    if (length > static_cast<long long>(remainingBufferSpace)) {
+        // If the buffer has hit maximum size, it can't be grown any more.
+        if (m_totalBytes >= numeric_limits<unsigned>::max()) {
+            failed(FileError::NOT_READABLE_ERR);
+            return;
+        }
+        if (m_variableLength) {
+            unsigned long long newLength = m_totalBytes * 2;
+            if (newLength > numeric_limits<unsigned>::max())
+                newLength = numeric_limits<unsigned>::max();
+            RefPtr<ArrayBuffer> newData =
+                ArrayBuffer::create(static_cast<unsigned>(newLength), 1);
+            memcpy(static_cast<char*>(newData->data()), static_cast<char*>(m_rawData->data()), m_bytesLoaded);
+
+            m_rawData = newData;
+            m_totalBytes = static_cast<unsigned>(newLength);
+        } else
+            length = remainingBufferSpace;
+    }
 
     if (length <= 0)
         return;
@@ -183,6 +218,12 @@ void FileReaderLoader::didReceiveData(const char* data, int dataLength)
 
 void FileReaderLoader::didFinishLoading(unsigned long, double)
 {
+    if (m_variableLength && m_totalBytes > m_bytesLoaded) {
+        RefPtr<ArrayBuffer> newData = m_rawData->slice(0, m_bytesLoaded);
+
+        m_rawData = newData;
+        m_totalBytes = m_bytesLoaded;
+    }
     cleanup();
     if (m_client)
         m_client->didFinishLoading();
@@ -233,9 +274,32 @@ PassRefPtr<ArrayBuffer> FileReaderLoader::arrayBufferResult() const
     return ArrayBuffer::create(m_rawData.get());
 }
 
+#if ENABLE(STREAM)
+PassRefPtr<Blob> FileReaderLoader::blobResult()
+{
+    ASSERT(m_readType == ReadAsBlob);
+
+    // If the loading is not finished or an error occurs, return an empty result.
+    if (!m_rawData || m_errorCode || !isCompleted())
+        return 0;
+
+    if (!m_blobResult) {
+        OwnPtr<BlobData> blobData = BlobData::create();
+        size_t size = 0;
+        RefPtr<RawData> rawData = RawData::create();
+        size = m_rawData->byteLength();
+        rawData->mutableData()->append(static_cast<char*>(m_rawData->data()), size);
+        blobData->appendData(rawData, 0, size);
+        blobData->setContentType(m_dataType);
+        m_blobResult = Blob::create(blobData.release(), size);
+    }
+    return m_blobResult;
+}
+#endif // ENABLE(STREAM)
+
 String FileReaderLoader::stringResult()
 {
-    ASSERT(m_readType != ReadAsArrayBuffer);
+    ASSERT(m_readType != ReadAsArrayBuffer && m_readType != ReadAsBlob);
 
     // If the loading is not started or an error occurs, return an empty result.
     if (!m_rawData || m_errorCode)
@@ -320,6 +384,16 @@ void FileReaderLoader::setEncoding(const String& encoding)
         m_encoding = TextEncoding(encoding);
 }
 
+#if ENABLE(STREAM)
+void FileReaderLoader::setRange(unsigned start, unsigned length)
+{
+    ASSERT(length > 0);
+    m_hasRange = true;
+    m_rangeStart = start;
+    m_rangeEnd = start + length - 1;
+}
+#endif // ENABLE(STREAM)
+
 } // namespace WebCore
  
 #endif // ENABLE(BLOB)