third_party/WebKit/Source/core/fileapi/FileReaderLoader.cpp

   1 /*
   2  * Copyright (C) 2010 Google Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32
  33 #include "core/fileapi/FileReaderLoader.h"
  34
  35 #include "core/dom/DOMArrayBuffer.h"
  36 #include "core/dom/ExecutionContext.h"
  37 #include "core/fetch/FetchInitiatorTypeNames.h"
  38 #include "core/fileapi/Blob.h"
  39 #include "core/fileapi/FileReaderLoaderClient.h"
  40 #include "core/html/parser/TextResourceDecoder.h"
  41 #include "core/loader/ThreadableLoader.h"
  42 #include "core/streams/Stream.h"
  43 #include "platform/blob/BlobRegistry.h"
  44 #include "platform/blob/BlobURL.h"
  45 #include "platform/network/ResourceRequest.h"
  46 #include "platform/network/ResourceResponse.h"
  47 #include "public/platform/WebURLRequest.h"
  48 #include "wtf/PassOwnPtr.h"
  49 #include "wtf/PassRefPtr.h"
  50 #include "wtf/RefPtr.h"
  51 #include "wtf/Vector.h"
  52 #include "wtf/text/Base64.h"
  53 #include "wtf/text/StringBuilder.h"
  54
  55 namespace blink {
  56
  57 FileReaderLoader::FileReaderLoader(ReadType readType, FileReaderLoaderClient* client)
  58     : m_readType(readType)
  59     , m_client(client)
  60     , m_urlForReadingIsStream(false)
  61     , m_isRawDataConverted(false)
  62     , m_stringResult("")
  63     , m_finishedLoading(false)
  64     , m_bytesLoaded(0)
  65     , m_totalBytes(-1)
  66     , m_hasRange(false)
  67     , m_rangeStart(0)
  68     , m_rangeEnd(0)
  69     , m_errorCode(FileError::OK)
  70 {
  71 }
  72
  73 FileReaderLoader::~FileReaderLoader()
  74 {
  75     terminate();
  76     if (!m_urlForReading.isEmpty()) {
  77         if (m_urlForReadingIsStream)
  78             BlobRegistry::unregisterStreamURL(m_urlForReading);
  79         else
  80             BlobRegistry::revokePublicBlobURL(m_urlForReading);
  81     }
  82 }
  83
  84 void FileReaderLoader::startInternal(ExecutionContext& executionContext, const Stream* stream, PassRefPtr<BlobDataHandle> blobData)
  85 {
  86     // The blob is read by routing through the request handling layer given a temporary public url.
  87     m_urlForReading = BlobURL::createPublicURL(executionContext.securityOrigin());
  88     if (m_urlForReading.isEmpty()) {
  89         failed(FileError::SECURITY_ERR);
  90         return;
  91     }
  92
  93     if (blobData) {
  94         ASSERT(!stream);
  95         BlobRegistry::registerPublicBlobURL(executionContext.securityOrigin(), m_urlForReading, blobData);
  96     } else {
  97         ASSERT(stream);
  98         BlobRegistry::registerStreamURL(executionContext.securityOrigin(), m_urlForReading, stream->url());
  99     }
 100
 101     // Construct and load the request.
 102     ResourceRequest request(m_urlForReading);
 103
 104     // FIXME: Should this really be 'internal'? Do we know anything about the actual request that generated this fetch?
 105     request.setRequestContext(WebURLRequest::RequestContextInternal);
 106
 107     request.setHTTPMethod("GET");
 108     if (m_hasRange)
 109         request.setHTTPHeaderField("Range", AtomicString(String::format("bytes=%d-%d", m_rangeStart, m_rangeEnd)));
 110
 111     ThreadableLoaderOptions options;
 112     options.preflightPolicy = ConsiderPreflight;
 113     options.crossOriginRequestPolicy = DenyCrossOriginRequests;
 114     // FIXME: Is there a directive to which this load should be subject?
 115     options.contentSecurityPolicyEnforcement = DoNotEnforceContentSecurityPolicy;
 116     // Use special initiator to hide the request from the inspector.
 117     options.initiator = FetchInitiatorTypeNames::internal;
 118
 119     ResourceLoaderOptions resourceLoaderOptions;
 120     resourceLoaderOptions.allowCredentials = AllowStoredCredentials;
 121
 122     if (m_client)
 123         m_loader = ThreadableLoader::create(executionContext, this, request, options, resourceLoaderOptions);
 124     else
 125         ThreadableLoader::loadResourceSynchronously(executionContext, request, *this, options, resourceLoaderOptions);
 126 }
 127
 128 void FileReaderLoader::start(ExecutionContext* executionContext, PassRefPtr<BlobDataHandle> blobData)
 129 {
 130     ASSERT(executionContext);
 131     m_urlForReadingIsStream = false;
 132     startInternal(*executionContext, 0, blobData);
 133 }
 134
 135 void FileReaderLoader::start(ExecutionContext* executionContext, const Stream& stream, unsigned readSize)
 136 {
 137     ASSERT(executionContext);
 138     if (readSize > 0) {
 139         m_hasRange = true;
 140         m_rangeStart = 0;
 141         m_rangeEnd = readSize - 1; // End is inclusive so (0,0) is a 1-byte read.
 142     }
 143
 144     m_urlForReadingIsStream = true;
 145     startInternal(*executionContext, &stream, nullptr);
 146 }
 147
 148 void FileReaderLoader::cancel()
 149 {
 150     m_errorCode = FileError::ABORT_ERR;
 151     terminate();
 152 }
 153
 154 void FileReaderLoader::terminate()
 155 {
 156     if (m_loader) {
 157         m_loader->cancel();
 158         cleanup();
 159     }
 160 }
 161
 162 void FileReaderLoader::cleanup()
 163 {
 164     m_loader = nullptr;
 165
 166     // If we get any error, we do not need to keep a buffer around.
 167     if (m_errorCode) {
 168         m_rawData.clear();
 169         m_stringResult = "";
 170         m_isRawDataConverted = true;
 171         m_decoder.clear();
 172     }
 173 }
 174
 175 void FileReaderLoader::didReceiveResponse(unsigned long, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 176 {
 177     ASSERT_UNUSED(handle, !handle);
 178     if (response.httpStatusCode() != 200) {
 179         failed(httpStatusCodeToErrorCode(response.httpStatusCode()));
 180         return;
 181     }
 182
 183     // A negative value means that the content length wasn't specified.
 184     m_totalBytes = response.expectedContentLength();
 185
 186     long long initialBufferLength = -1;
 187
 188     if (m_totalBytes >= 0) {
 189         initialBufferLength = m_totalBytes;
 190     } else if (m_hasRange) {
 191         // Set m_totalBytes and allocate a buffer based on the specified range.
 192         m_totalBytes = 1LL + m_rangeEnd - m_rangeStart;
 193         initialBufferLength = m_totalBytes;
 194     } else {
 195         // Nothing is known about the size of the resource. Normalize
 196         // m_totalBytes to -1 and initialize the buffer for receiving with the
 197         // default size.
 198         m_totalBytes = -1;
 199     }
 200
 201     ASSERT(!m_rawData);
 202
 203     if (m_readType != ReadByClient) {
 204         // Check that we can cast to unsigned since we have to do
 205         // so to call ArrayBuffer's create function.
 206         // FIXME: Support reading more than the current size limit of ArrayBuffer.
 207         if (initialBufferLength > std::numeric_limits<unsigned>::max()) {
 208             failed(FileError::NOT_READABLE_ERR);
 209             return;
 210         }
 211
 212         if (initialBufferLength < 0)
 213             m_rawData = adoptPtr(new ArrayBufferBuilder());
 214         else
 215             m_rawData = adoptPtr(new ArrayBufferBuilder(static_cast<unsigned>(initialBufferLength)));
 216
 217         if (!m_rawData || !m_rawData->isValid()) {
 218             failed(FileError::NOT_READABLE_ERR);
 219             return;
 220         }
 221
 222         if (initialBufferLength >= 0) {
 223             // Total size is known. Set m_rawData to ignore overflowed data.
 224             m_rawData->setVariableCapacity(false);
 225         }
 226     }
 227
 228     if (m_client)
 229         m_client->didStartLoading();
 230 }
 231
 232 void FileReaderLoader::didReceiveData(const char* data, unsigned dataLength)
 233 {
 234     ASSERT(data);
 235
 236     // Bail out if we already encountered an error.
 237     if (m_errorCode)
 238         return;
 239
 240     if (m_readType == ReadByClient) {
 241         m_bytesLoaded += dataLength;
 242
 243         if (m_client)
 244             m_client->didReceiveDataForClient(data, dataLength);
 245         return;
 246     }
 247
 248     unsigned bytesAppended = m_rawData->append(data, dataLength);
 249     if (!bytesAppended) {
 250         m_rawData.clear();
 251         m_bytesLoaded = 0;
 252         failed(FileError::NOT_READABLE_ERR);
 253         return;
 254     }
 255     m_bytesLoaded += bytesAppended;
 256     m_isRawDataConverted = false;
 257
 258     if (m_client)
 259         m_client->didReceiveData();
 260 }
 261
 262 void FileReaderLoader::didFinishLoading(unsigned long, double)
 263 {
 264     if (m_readType != ReadByClient && m_rawData) {
 265         m_rawData->shrinkToFit();
 266         m_isRawDataConverted = false;
 267     }
 268
 269     if (m_totalBytes == -1) {
 270         // Update m_totalBytes only when in dynamic buffer grow mode.
 271         m_totalBytes = m_bytesLoaded;
 272     }
 273
 274     m_finishedLoading = true;
 275
 276     cleanup();
 277     if (m_client)
 278         m_client->didFinishLoading();
 279 }
 280
 281 void FileReaderLoader::didFail(const ResourceError&)
 282 {
 283     // If we're aborting, do not proceed with normal error handling since it is covered in aborting code.
 284     if (m_errorCode == FileError::ABORT_ERR)
 285         return;
 286
 287     failed(FileError::NOT_READABLE_ERR);
 288 }
 289
 290 void FileReaderLoader::failed(FileError::ErrorCode errorCode)
 291 {
 292     m_errorCode = errorCode;
 293     cleanup();
 294     if (m_client)
 295         m_client->didFail(m_errorCode);
 296 }
 297
 298 FileError::ErrorCode FileReaderLoader::httpStatusCodeToErrorCode(int httpStatusCode)
 299 {
 300     switch (httpStatusCode) {
 301     case 403:
 302         return FileError::SECURITY_ERR;
 303     case 404:
 304         return FileError::NOT_FOUND_ERR;
 305     default:
 306         return FileError::NOT_READABLE_ERR;
 307     }
 308 }
 309
 310 PassRefPtr<DOMArrayBuffer> FileReaderLoader::arrayBufferResult() const
 311 {
 312     ASSERT(m_readType == ReadAsArrayBuffer);
 313
 314     // If the loading is not started or an error occurs, return an empty result.
 315     if (!m_rawData || m_errorCode)
 316         return nullptr;
 317
 318     return DOMArrayBuffer::create(m_rawData->toArrayBuffer());
 319 }
 320
 321 String FileReaderLoader::stringResult()
 322 {
 323     ASSERT(m_readType != ReadAsArrayBuffer && m_readType != ReadByClient);
 324
 325     // If the loading is not started or an error occurs, return an empty result.
 326     if (!m_rawData || m_errorCode)
 327         return m_stringResult;
 328
 329     // If already converted from the raw data, return the result now.
 330     if (m_isRawDataConverted)
 331         return m_stringResult;
 332
 333     switch (m_readType) {
 334     case ReadAsArrayBuffer:
 335         // No conversion is needed.
 336         break;
 337     case ReadAsBinaryString:
 338         m_stringResult = m_rawData->toString();
 339         m_isRawDataConverted = true;
 340         break;
 341     case ReadAsText:
 342         convertToText();
 343         break;
 344     case ReadAsDataURL:
 345         // Partial data is not supported when reading as data URL.
 346         if (m_finishedLoading)
 347             convertToDataURL();
 348         break;
 349     default:
 350         ASSERT_NOT_REACHED();
 351     }
 352
 353     return m_stringResult;
 354 }
 355
 356 void FileReaderLoader::convertToText()
 357 {
 358     m_isRawDataConverted = true;
 359
 360     if (!m_bytesLoaded) {
 361         m_stringResult = "";
 362         return;
 363     }
 364
 365     // Decode the data.
 366     // The File API spec says that we should use the supplied encoding if it is valid. However, we choose to ignore this
 367     // requirement in order to be consistent with how WebKit decodes the web content: always has the BOM override the
 368     // provided encoding.
 369     // FIXME: consider supporting incremental decoding to improve the perf.
 370     StringBuilder builder;
 371     if (!m_decoder)
 372         m_decoder = TextResourceDecoder::create("text/plain", m_encoding.isValid() ? m_encoding : UTF8Encoding());
 373     builder.append(m_decoder->decode(static_cast<const char*>(m_rawData->data()), m_rawData->byteLength()));
 374
 375     if (m_finishedLoading)
 376         builder.append(m_decoder->flush());
 377
 378     m_stringResult = builder.toString();
 379 }
 380
 381 void FileReaderLoader::convertToDataURL()
 382 {
 383     m_isRawDataConverted = true;
 384
 385     StringBuilder builder;
 386     builder.appendLiteral("data:");
 387
 388     if (!m_bytesLoaded) {
 389         m_stringResult = builder.toString();
 390         return;
 391     }
 392
 393     builder.append(m_dataType);
 394     builder.appendLiteral(";base64,");
 395
 396     Vector<char> out;
 397     base64Encode(static_cast<const char*>(m_rawData->data()), m_rawData->byteLength(), out);
 398     out.append('\0');
 399     builder.append(out.data());
 400
 401     m_stringResult = builder.toString();
 402 }
 403
 404 void FileReaderLoader::setEncoding(const String& encoding)
 405 {
 406     if (!encoding.isEmpty())
 407         m_encoding = WTF::TextEncoding(encoding);
 408 }
 409
 410 } // namespace blink