⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 227760 in webkit


Ignore:
Timestamp:
Jan 29, 2018, 3:39:21 PM (9 years ago)
Author:
gskachkov@gmail.com
Message:

FetchResponse should support ConsumeData callback on chunk data is received: handling ReadableStream bodies
​https://bugs.webkit.org/show_bug.cgi?id=182008

Reviewed by Youenn Fablet.

LayoutTests/imported/w3c:

  • web-platform-tests/service-workers/service-worker/fetch-event-respond-with-readable-stream-chunk.https-expected.txt: Added.
  • web-platform-tests/service-workers/service-worker/fetch-event-respond-with-readable-stream-chunk.https.html: Added.
  • web-platform-tests/service-workers/service-worker/resources/fetch-event-respond-with-readable-stream-chunk-iframe.html: Added.
  • web-platform-tests/service-workers/service-worker/resources/fetch-event-respond-with-readable-stream-chunk-worker.js: Added.

(const.process):
(this.step):
(this.run):
(const.asyncSteps):

Source/WebCore:

Modify FetchResponse to support ConsumeData callback with
handling of ReadableStream by chunks

  • Modules/cache/DOMCache.cpp:

(WebCore::DOMCache::put):

  • Modules/fetch/FetchBodyConsumer.cpp:

(WebCore::FetchBodyConsumer::resolve):

  • Modules/fetch/FetchResponse.cpp:

(WebCore::FetchResponse::consumeBodyFromReadableStream):

  • Modules/fetch/FetchResponse.h:
  • Modules/streams/ReadableStreamChunk.h: Added.
  • Modules/streams/ReadableStreamSink.cpp:

(WebCore::ReadableStreamToSharedBufferSink::enqueue):
(WebCore::ReadableStreamToSharedBufferSink::close):

  • Modules/streams/ReadableStreamSink.h:
  • WebCore.xcodeproj/project.pbxproj:
  • workers/service/context/ServiceWorkerFetch.cpp:

(WebCore::ServiceWorkerFetch::processResponse):

Location:
trunk
Files:
4 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r227714 r227760  
     12018-01-29  Oleksandr Skachkov  <gskachkov@gmail.com>
     2
     3        FetchResponse should support ConsumeData callback on chunk data is received: handling ReadableStream bodies
     4        https://bugs.webkit.org/show_bug.cgi?id=182008
     5
     6        Reviewed by Youenn Fablet.
     7
     8        * web-platform-tests/service-workers/service-worker/fetch-event-respond-with-readable-stream-chunk.https-expected.txt: Added.
     9        * web-platform-tests/service-workers/service-worker/fetch-event-respond-with-readable-stream-chunk.https.html: Added.
     10        * web-platform-tests/service-workers/service-worker/resources/fetch-event-respond-with-readable-stream-chunk-iframe.html: Added.
     11        * web-platform-tests/service-workers/service-worker/resources/fetch-event-respond-with-readable-stream-chunk-worker.js: Added.
     12        (const.process):
     13        (this.step):
     14        (this.run):
     15        (const.asyncSteps):
     16
    1172018-01-26  Antoine Quint  <graouts@apple.com>
    218

  • trunk/Source/WebCore/ChangeLog

    r227759 r227760  
     12018-01-29  Oleksandr Skachkov  <gskachkov@gmail.com>
     2
     3        FetchResponse should support ConsumeData callback on chunk data is received: handling ReadableStream bodies
     4        https://bugs.webkit.org/show_bug.cgi?id=182008
     5
     6        Reviewed by Youenn Fablet.
     7
     8        Modify FetchResponse to support ConsumeData callback with
     9        handling of ReadableStream by chunks
     10
     11        * Modules/cache/DOMCache.cpp:
     12        (WebCore::DOMCache::put):
     13        * Modules/fetch/FetchBodyConsumer.cpp:
     14        (WebCore::FetchBodyConsumer::resolve):
     15        * Modules/fetch/FetchResponse.cpp:
     16        (WebCore::FetchResponse::consumeBodyFromReadableStream):
     17        * Modules/fetch/FetchResponse.h:
     18        * Modules/streams/ReadableStreamChunk.h: Added.
     19        * Modules/streams/ReadableStreamSink.cpp:
     20        (WebCore::ReadableStreamToSharedBufferSink::enqueue):
     21        (WebCore::ReadableStreamToSharedBufferSink::close):
     22        * Modules/streams/ReadableStreamSink.h:
     23        * WebCore.xcodeproj/project.pbxproj:
     24        * workers/service/context/ServiceWorkerFetch.cpp:
     25        (WebCore::ServiceWorkerFetch::processResponse):
     26
    1272018-01-29  Andy Estes  <aestes@apple.com>
    228

  • trunk/Source/WebCore/Modules/cache/DOMCache.cpp

    r227339 r227760  
    3232#include "JSFetchRequest.h"
    3333#include "JSFetchResponse.h"
     34#include "ReadableStreamChunk.h"
    3435#include "ScriptExecutionContext.h"
    3536#include "URL.h"
    … …  
    333334
    334335    if (response->hasReadableStreamBody()) {
    335         setPendingActivity(this);
    336         response->consumeBodyFromReadableStream([promise = WTFMove(promise), request = WTFMove(request), response = WTFMove(response), this](ExceptionOr<RefPtr<SharedBuffer>>&& result) mutable {
    337             putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), WTFMove(result));
    338             unsetPendingActivity(this);
     336        response->consumeBodyFromReadableStream([promise = WTFMove(promise), request = WTFMove(request), response = WTFMove(response), data = SharedBuffer::create(), pendingActivity = makePendingActivity(*this), this](auto&& result) mutable {
     337
     338            if (result.hasException()) {
     339                this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), result.releaseException().isolatedCopy());
     340                return;
     341            }
     342
     343            if (auto chunk = result.returnValue())
     344                data->append(reinterpret_cast<const char*>(chunk->data), chunk->size);
     345            else
     346                this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), RefPtr<SharedBuffer> { WTFMove(data) });
    339347        });
    340348        return;

  • trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp

    r221772 r227760  
    3131
    3232#include "JSBlob.h"
     33#include "ReadableStreamChunk.h"
    3334#include "TextResourceDecoder.h"
    3435
    … …  
    104105    if (stream) {
    105106        ASSERT(!m_sink);
    106         m_sink = ReadableStreamToSharedBufferSink::create([promise = WTFMove(promise), type = m_type, contentType = m_contentType](ExceptionOr<RefPtr<SharedBuffer>>&& result) mutable {
     107        m_sink = ReadableStreamToSharedBufferSink::create([promise = WTFMove(promise), data = SharedBuffer::create(), type = m_type, contentType = m_contentType](auto&& result) mutable {
    107108            if (result.hasException()) {
    108109                promise->reject(result.releaseException());
    … …  
    110111            }
    111112
    112             auto* data = result.returnValue() && result.returnValue()->data() ? reinterpret_cast<const unsigned char*>(result.returnValue()->data()) : nullptr;
    113             auto size = data ? result.returnValue()->size() : 0;
    114             resolveWithTypeAndData(WTFMove(promise), type, contentType, data, size);
     113            if (auto chunk = result.returnValue())
     114                data->append(reinterpret_cast<const char*>(chunk->data), chunk->size);
     115            else
     116                resolveWithTypeAndData(WTFMove(promise), type, contentType, reinterpret_cast<const unsigned char*>(data->data()), data->size());
    115117        });
    116118        m_sink->pipeFrom(*stream);

  • trunk/Source/WebCore/Modules/fetch/FetchResponse.cpp

    r227581 r227760  
    3434#include "JSBlob.h"
    3535#include "MIMETypeRegistry.h"
     36#include "ReadableStreamSink.h"
    3637#include "ResourceError.h"
    3738#include "ScriptExecutionContext.h"
    … …  
    340341}
    341342
    342 void FetchResponse::consumeBodyFromReadableStream(ConsumeDataCallback&& callback)
     343void FetchResponse::consumeBodyFromReadableStream(ConsumeDataByChunkCallback&& callback)
    343344{
    344345    ASSERT(m_body);

  • trunk/Source/WebCore/Modules/fetch/FetchResponse.h

    r227339 r227760  
    3131#include "FetchBodyOwner.h"
    3232#include "FetchHeaders.h"
     33#include "ReadableStreamSink.h"
    3334#include "ResourceResponse.h"
    3435#include <runtime/TypedArrays.h>
    … …  
    4243
    4344class FetchRequest;
     45struct ReadableStreamChunk;
    4446class ReadableStreamSource;
    4547
    … …  
    9496    using ConsumeDataCallback = WTF::Function<void(ExceptionOr<RefPtr<SharedBuffer>>&&)>;
    9597    void consumeBodyWhenLoaded(ConsumeDataCallback&&);
    96     void consumeBodyFromReadableStream(ConsumeDataCallback&&);
     98
     99    using ConsumeDataByChunkCallback = WTF::Function<void(ExceptionOr<ReadableStreamChunk*>&&)>;
     100    void consumeBodyFromReadableStream(ConsumeDataByChunkCallback&&);
    97101
    98102    WEBCORE_EXPORT ResourceResponse resourceResponse() const;

  • trunk/Source/WebCore/Modules/streams/ReadableStreamSink.cpp

    r224903 r227760  
    5252        return;
    5353
    54     if (!m_data) {
    55         m_data = SharedBuffer::create(buffer.data(), buffer.length());
    56         return;
     54    if (m_callback) {
     55        ReadableStreamChunk chunk { buffer.data(), buffer.length() };
     56        m_callback(&chunk);
    5757    }
    58     m_data->append(reinterpret_cast<const char*>(buffer.data()), buffer.length());
    5958}
    6059
    6160void ReadableStreamToSharedBufferSink::close()
    6261{
    63     if (auto callback = WTFMove(m_callback))
    64         callback(WTFMove(m_data));
     62    if (m_callback)
     63        m_callback(nullptr);
    6564}
    6665

  • trunk/Source/WebCore/Modules/streams/ReadableStreamSink.h

    r221504 r227760  
    3030
    3131#include "ExceptionOr.h"
     32#include "ReadableStreamChunk.h"
    3233#include <wtf/Function.h>
    3334#include <wtf/RefCounted.h>
    … …  
    3738class BufferSource;
    3839class ReadableStream;
     40struct ReadableStreamChunk;
    3941class SharedBuffer;
    4042
    … …  
    5052class ReadableStreamToSharedBufferSink final : public ReadableStreamSink {
    5153public:
    52     using Callback = WTF::Function<void(ExceptionOr<RefPtr<SharedBuffer>>&&)>;
     54    using Callback = WTF::Function<void(ExceptionOr<ReadableStreamChunk*>&&)>;
    5355    static Ref<ReadableStreamToSharedBufferSink> create(Callback&& callback) { return adoptRef(*new ReadableStreamToSharedBufferSink(WTFMove(callback))); }
    5456    void pipeFrom(ReadableStream&);
    … …  
    5658
    5759private:
    58     ReadableStreamToSharedBufferSink(Callback&&);
     60    explicit ReadableStreamToSharedBufferSink(Callback&&);
    5961
    6062    void enqueue(const BufferSource&) final;
    … …  
    6365
    6466    Callback m_callback;
    65     RefPtr<SharedBuffer> m_data;
    6667};
    6768

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r227714 r227760  
    23902390                8AF4E55611DC5A36000ED3DE /* PerformanceNavigation.h in Headers */ = {isa = PBXBuildFile; fileRef = 8AF4E55311DC5A36000ED3DE /* PerformanceNavigation.h */; };
    23912391                8AF4E55C11DC5A63000ED3DE /* PerformanceTiming.h in Headers */ = {isa = PBXBuildFile; fileRef = 8AF4E55911DC5A63000ED3DE /* PerformanceTiming.h */; };
     2392                8BD37A68201BB39C0011734A /* ReadableStreamChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BD37A67201BB39C0011734A /* ReadableStreamChunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
    23922393                8E4C96DD1AD4483500365A50 /* JSFetchResponse.h in Headers */ = {isa = PBXBuildFile; fileRef = 8E4C96D91AD4483500365A50 /* JSFetchResponse.h */; };
    23932394                8EC6C963201A251600FBFA53 /* GapLength.h in Headers */ = {isa = PBXBuildFile; fileRef = 8EC6C961201A250100FBFA53 /* GapLength.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    99389939                8AF4E55A11DC5A63000ED3DE /* PerformanceTiming.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = PerformanceTiming.idl; sourceTree = "<group>"; };
    99399940                8E33CD93201A29C100E39093 /* GapLength.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GapLength.cpp; sourceTree = "<group>"; };
     9941                8BD37A67201BB39C0011734A /* ReadableStreamChunk.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ReadableStreamChunk.h; sourceTree = "<group>"; };
    99409942                8E4C96D81AD4483500365A50 /* JSFetchResponse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSFetchResponse.cpp; sourceTree = "<group>"; };
    99419943                8E4C96D91AD4483500365A50 /* JSFetchResponse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSFetchResponse.h; sourceTree = "<group>"; };
    … …  
    1656916571                                41189EF71AD8232800B95672 /* ReadableStreamBYOBRequest.idl */,
    1657016572                                9908B0F01BCACF9100ED5672 /* ReadableStreamBYOBRequest.js */,
     16573                                8BD37A67201BB39C0011734A /* ReadableStreamChunk.h */,
    1657116574                                41189EF71AD8232800B90A0D /* ReadableStreamDefaultController.idl */,
    1657216575                                9908B0F01BCACF9100ED0F65 /* ReadableStreamDefaultController.js */,
    … …  
    2909329096                                416E6FE81BBD12DF000A6043 /* ReadableByteStreamInternalsBuiltins.h in Headers */,
    2909429097                                416E6FE91BBD12E5000A6043 /* ReadableStreamBuiltins.h in Headers */,
     29098                                8BD37A68201BB39C0011734A /* ReadableStreamChunk.h in Headers */,
    2909529099                                4129C9A91F59C56B009D7403 /* ReadableStreamDefaultController.h in Headers */,
    2909629100                                416E6FE81BBD12DF000A3F64 /* ReadableStreamInternalsBuiltins.h in Headers */,

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerFetch.cpp

    r227070 r227760  
    3434#include "FetchRequest.h"
    3535#include "FetchResponse.h"
     36#include "ReadableStreamChunk.h"
    3637#include "ResourceRequest.h"
    3738#include "ServiceWorker.h"
    … …  
    5455
    5556    if (response->hasReadableStreamBody()) {
    56         // FIXME: We should send the body as chunks.
    57         response->consumeBodyFromReadableStream([client = WTFMove(client)] (ExceptionOr<RefPtr<SharedBuffer>>&& result) mutable {
     57        response->consumeBodyFromReadableStream([client = WTFMove(client)] (auto&& result) mutable {
    5858            if (result.hasException()) {
    5959                client->didFail();
    … …  
    6161            }
    6262
    63             if (auto buffer = result.releaseReturnValue())
    64                 client->didReceiveData(buffer.releaseNonNull());
    65             client->didFinish();
     63            if (auto chunk = result.returnValue())
     64                client->didReceiveData(SharedBuffer::create(reinterpret_cast<const char*>(chunk->data), chunk->size));
     65            else
     66                client->didFinish();
    6667        });
    6768        return;
Note: See TracChangeset for help on using the changeset viewer.