Add Stream support to FileReaderLoader.

Source/core/fileapi/FileReaderLoader.cpp

 /*
  * Copyright (C) 2010 Google Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #include "config.h"
 
 #include "core/fileapi/FileReaderLoader.h"
 
 #include "core/dom/ScriptExecutionContext.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/BlobRegistry.h"
 #include "core/fileapi/BlobURL.h"
 #include "core/fileapi/FileReaderLoaderClient.h"
+#include "core/fileapi/Stream.h"
 #include "core/loader/TextResourceDecoder.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/platform/network/ResourceRequest.h"
 #include "core/platform/network/ResourceResponse.h"
 #include <wtf/ArrayBuffer.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 #include <wtf/text/Base64.h>
 #include <wtf/text/StringBuilder.h>
 #include <wtf/Vector.h>
@@ skipping 19 matching lines @@
 {
 }
 
 FileReaderLoader::~FileReaderLoader()
 {
     terminate();
     if (!m_urlForReading.isEmpty())
         BlobRegistry::unregisterBlobURL(m_urlForReading);
 }
 
-void FileReaderLoader::start(ScriptExecutionContext* scriptExecutionContext, Blob* blob)
+void FileReaderLoader::startForURL(ScriptExecutionContext* scriptExecutionContext, const KURL& url)
 {
     // The blob is read by routing through the request handling layer given a temporary public url.
     m_urlForReading = BlobURL::createPublicURL(scriptExecutionContext->securityOrigin());
     if (m_urlForReading.isEmpty()) {
         failed(FileError::SECURITY_ERR);
         return;
     }
-    BlobRegistry::registerBlobURL(scriptExecutionContext->securityOrigin(), m_urlForReading, blob->url());
+    BlobRegistry::registerBlobURL(scriptExecutionContext->securityOrigin(), m_urlForReading, url);
 
     // 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;
     options.sniffContent = DoNotSniffContent;
     options.preflightPolicy = ConsiderPreflight;
     options.allowCredentials = AllowStoredCredentials;
     options.crossOriginRequestPolicy = DenyCrossOriginRequests;
     // FIXME: Is there a directive to which this load should be subject?
     options.contentSecurityPolicyEnforcement = DoNotEnforceContentSecurityPolicy;
 
     if (m_client)
         m_loader = ThreadableLoader::create(scriptExecutionContext, this, request, options);
     else
         ThreadableLoader::loadResourceSynchronously(scriptExecutionContext, request, *this, options);
 }
 
+void FileReaderLoader::start(ScriptExecutionContext* scriptExecutionContext, Blob* blob)
+{
+    startForURL(scriptExecutionContext, blob->url());
+}
+
+void FileReaderLoader::start(ScriptExecutionContext* scriptExecutionContext, Stream* stream)

[tkent, 2013/07/12 09:03:49]

nit: We assume |steram| is non-0.  So we had better make the argument type
"const Stream&."

[tyoshino (SeeGerritForStatus), 2013/07/12 11:15:17]

Done

+{
+    startForURL(scriptExecutionContext, stream->url());
+}
+
 void FileReaderLoader::cancel()
 {
     m_errorCode = FileError::ABORT_ERR;
     terminate();
 }
 
 void FileReaderLoader::terminate()
 {
     if (m_loader) {
         m_loader->cancel();
@@ skipping 268 matching lines @@
 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