Changeset 206912 in webkit


Ignore:
Timestamp:
Oct 7, 2016 8:10:46 AM (7 years ago)
Author:
commit-queue@webkit.org
Message:

[Readable Streams API] Implement generic reader functions
https://bugs.webkit.org/show_bug.cgi?id=163003

Patch by Romain Bellessort <romain.bellessort@crf.canon.fr> on 2016-10-07
Reviewed by Darin Adler.

Implements reader generic functions defined by spec in order to prepare BYOBReader integration.
Generic functions factorize some code that is used by both DefaultReader and BYOBReader.

No change in behaviour.

  • Modules/streams/ReadableStreamDefaultReader.js:

(cancel): Rely on readableStreamReaderGenericCancel.
(releaseLock): Rely on readableStreamReaderGenericRelease.

  • Modules/streams/ReadableStreamInternals.js:

(privateInitializeReadableStreamDefaultReader): Rely on readableStreamReaderGenericInitialize.
(readableStreamReaderGenericInitialize): Added.
(readableStreamReaderGenericCancel): Added.
(readableStreamReaderGenericRelease): Added.

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r206908 r206912  
     12016-10-07  Romain Bellessort  <romain.bellessort@crf.canon.fr>
     2
     3        [Readable Streams API] Implement generic reader functions
     4        https://bugs.webkit.org/show_bug.cgi?id=163003
     5
     6        Reviewed by Darin Adler.
     7
     8        Implements reader generic functions defined by spec in order to prepare BYOBReader integration.
     9        Generic functions factorize some code that is used by both DefaultReader and BYOBReader.
     10
     11        No change in behaviour.
     12
     13        * Modules/streams/ReadableStreamDefaultReader.js:
     14        (cancel): Rely on readableStreamReaderGenericCancel.
     15        (releaseLock): Rely on readableStreamReaderGenericRelease.
     16        * Modules/streams/ReadableStreamInternals.js:
     17        (privateInitializeReadableStreamDefaultReader): Rely on readableStreamReaderGenericInitialize.
     18        (readableStreamReaderGenericInitialize): Added.
     19        (readableStreamReaderGenericCancel): Added.
     20        (readableStreamReaderGenericRelease): Added.
     21
    1222016-10-07  Adam Bergkvist  <adam.bergkvist@ericsson.com>
    223
  • trunk/Source/WebCore/Modules/streams/ReadableStreamDefaultReader.js

    r206870 r206912  
    3636        return @Promise.@reject(new @TypeError("cancel() called on a reader owned by no readable stream"));
    3737
    38     return @readableStreamCancel(this.@ownerReadableStream, reason);
     38    return @readableStreamReaderGenericCancel(this, reason);
    3939}
    4040
     
    5858        throw @makeThisTypeError("ReadableStreamDefaultReader", "releaseLock");
    5959
    60     const stream = this.@ownerReadableStream;
    61     if (!stream)
    62          return;
     60    if (!this.@ownerReadableStream)
     61        return;
    6362
    6463    if (this.@readRequests.length)
    6564        @throwTypeError("There are still pending read requests, cannot release the lock");
    6665
    67     if (stream.@state === @streamReadable)
    68         this.@closedPromiseCapability.@reject.@call(@undefined, new @TypeError("releasing lock of reader whose stream is still in readable state"));
    69     else
    70         this.@closedPromiseCapability = { @promise: @Promise.@reject(new @TypeError("reader released lock")) };
    71 
    72     stream.@reader = @undefined;
    73     this.@ownerReadableStream = null;
     66    @readableStreamReaderGenericRelease(this);
    7467}
    7568
  • trunk/Source/WebCore/Modules/streams/ReadableStreamInternals.js

    r206870 r206912  
    3737       @throwTypeError("ReadableStream is locked");
    3838
     39    @readableStreamReaderGenericInitialize(this, stream);
    3940    this.@readRequests = [];
    40     this.@ownerReadableStream = stream;
    41     stream.@reader = this;
    42     if (stream.@state === @streamReadable) {
    43         this.@closedPromiseCapability = @newPromiseCapability(@Promise);
    44         return this;
    45     }
    46     if (stream.@state === @streamClosed) {
    47         this.@closedPromiseCapability = { @promise: @Promise.@resolve() };
    48         return this;
    49     }
    50     @assert(stream.@state === @streamErrored);
    51     this.@closedPromiseCapability = { @promise: @Promise.@reject(stream.@storedError) };
    5241
    5342    return this;
     43}
     44
     45function readableStreamReaderGenericInitialize(reader, stream)
     46{
     47    "use strict";
     48
     49    reader.@ownerReadableStream = stream;
     50    stream.@reader = reader;
     51    if (stream.@state === @streamReadable)
     52        reader.@closedPromiseCapability = @newPromiseCapability(@Promise);
     53    else if (stream.@state === @streamClosed)
     54        reader.@closedPromiseCapability = { @promise: @Promise.@resolve() };
     55    else {
     56        @assert(stream.@state === @streamErrored);
     57        reader.@closedPromiseCapability = { @promise: @Promise.@reject(stream.@storedError) };
     58    }
    5459}
    5560
     
    324329}
    325330
     331
     332function readableStreamReaderGenericCancel(reader, reason)
     333{
     334    "use strict";
     335
     336    const stream = reader.@ownerReadableStream;
     337    @assert(!!stream);
     338    return @readableStreamCancel(stream, reason);
     339}
     340
    326341function readableStreamCancel(stream, reason)
    327342{
     
    461476    return stream.@disturbed;
    462477}
     478
     479function readableStreamReaderGenericRelease(reader)
     480{
     481    "use strict";
     482
     483    @assert(!!reader.@ownerReadableStream);
     484    @assert(reader.@ownerReadableStream.@reader === reader);
     485
     486    if (reader.@ownerReadableStream.@state === @streamReadable)
     487        reader.@closedPromiseCapability.@reject.@call(@undefined, new @TypeError("releasing lock of reader whose stream is still in readable state"));
     488    else
     489        reader.@closedPromiseCapability = { @promise: @Promise.@reject(new @TypeError("reader released lock")) };
     490
     491    reader.@ownerReadableStream.@reader = @undefined;
     492    reader.@ownerReadableStream = null;
     493}
Note: See TracChangeset for help on using the changeset viewer.