Changeset 192021 in webkit


Ignore:
Timestamp:
Nov 4, 2015 3:15:51 AM (9 years ago)
Author:
calvaris@igalia.com
Message:

[Streams API] Shield streams against user replacing the Promise constructor
​https://bugs.webkit.org/show_bug.cgi?id=150887

Reviewed by Youenn Fablet.

Source/WebCore:

With this rework, we shield the Streams implementation against the user doing something like "Promise =
function() { /* do garbage */ };".

Test: streams/streams-promises.html.

  • Modules/streams/ReadableStream.js:

(initializeReadableStream):
(cancel):

  • Modules/streams/ReadableStreamInternals.js:

(privateInitializeReadableStreamReader):
(cancelReadableStream):
(readFromReadableStreamReader):

  • Modules/streams/ReadableStreamReader.js:

(cancel):
(read):
(closed):

  • Modules/streams/StreamInternals.js:

(promiseInvokeOrNoop):
(promiseInvokeOrFallbackOrNoop):

  • Modules/streams/WritableStream.js:

(initializeWritableStream):
(abort):
(close):
(write):
(closed):
(ready):

  • Modules/streams/WritableStreamInternals.js:

(syncWritableStreamStateWithQueue):

LayoutTests:

  • streams/streams-promises-expected.txt: Added.
  • streams/streams-promises.html: Added.
Location:
trunk
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r192020 r192021  
     12015-11-04  Xabier Rodriguez Calvar  <calvaris@igalia.com>
     2
     3        [Streams API] Shield streams against user replacing the Promise constructor
     4        https://bugs.webkit.org/show_bug.cgi?id=150887
     5
     6        Reviewed by Youenn Fablet.
     7
     8        * streams/streams-promises-expected.txt: Added.
     9        * streams/streams-promises.html: Added.
     10
    1112015-11-04  Antoine Quint  <graouts@apple.com>
    212

  • trunk/Source/WebCore/ChangeLog

    r192020 r192021  
     12015-11-04  Xabier Rodriguez Calvar  <calvaris@igalia.com>
     2
     3        [Streams API] Shield streams against user replacing the Promise constructor
     4        https://bugs.webkit.org/show_bug.cgi?id=150887
     5
     6        Reviewed by Youenn Fablet.
     7
     8        With this rework, we shield the Streams implementation against the user doing something like "Promise =
     9        function() { /* do garbage */ };".
     10
     11        Test: streams/streams-promises.html.
     12
     13        * Modules/streams/ReadableStream.js:
     14        (initializeReadableStream):
     15        (cancel):
     16        * Modules/streams/ReadableStreamInternals.js:
     17        (privateInitializeReadableStreamReader):
     18        (cancelReadableStream):
     19        (readFromReadableStreamReader):
     20        * Modules/streams/ReadableStreamReader.js:
     21        (cancel):
     22        (read):
     23        (closed):
     24        * Modules/streams/StreamInternals.js:
     25        (promiseInvokeOrNoop):
     26        (promiseInvokeOrFallbackOrNoop):
     27        * Modules/streams/WritableStream.js:
     28        (initializeWritableStream):
     29        (abort):
     30        (close):
     31        (write):
     32        (closed):
     33        (ready):
     34        * Modules/streams/WritableStreamInternals.js:
     35        (syncWritableStreamStateWithQueue):
     36
    1372015-11-04  Antoine Quint  <graouts@apple.com>
    238

  • trunk/Source/WebCore/Modules/streams/ReadableStream.js

    r191730 r192021  
    5757    var result = @invokeOrNoop(underlyingSource, "start", [this.@controller]);
    5858    var _this = this;
    59     Promise.resolve(result).then(function() {
     59    @Promise.resolve(result).then(function() {
    6060        _this.@started = true;
    6161        @requestReadableStreamPull(_this);
    … …  
    7373
    7474    if (!@isReadableStream(this))
    75         return Promise.reject(new @TypeError("Function should be called on a ReadableStream"));
     75        return @Promise.reject(new @TypeError("Function should be called on a ReadableStream"));
    7676
    7777    if (@isReadableStreamLocked(this))
    78         return Promise.reject(new @TypeError("ReadableStream is locked"));
     78        return @Promise.reject(new @TypeError("ReadableStream is locked"));
    7979
    8080    return @cancelReadableStream(this, reason);

  • trunk/Source/WebCore/Modules/streams/ReadableStreamInternals.js

    r191956 r192021  
    4343        this.@storedError = undefined;
    4444        stream.@reader = this;
    45         this.@closedPromiseCapability = @newPromiseCapability(Promise);
     45        this.@closedPromiseCapability = @newPromiseCapability(@Promise);
    4646        return this;
    4747    }
    … …  
    4949        this.@ownerReadableStream = null;
    5050        this.@storedError = undefined;
    51         this.@closedPromiseCapability = { @promise: Promise.resolve(undefined) };
     51        this.@closedPromiseCapability = { @promise: @Promise.resolve(undefined) };
    5252        return this;
    5353    }
    … …  
    5555    this.@ownerReadableStream = null;
    5656    this.@storedError = stream.@storedError;
    57     this.@closedPromiseCapability = { @promise: Promise.reject(stream.@storedError) };
     57    this.@closedPromiseCapability = { @promise: @Promise.reject(stream.@storedError) };
    5858
    5959    return this;
    … …  
    276276
    277277    if (stream.@state === @streamClosed)
    278         return Promise.resolve();
     278        return @Promise.resolve();
    279279    if (stream.@state === @streamErrored)
    280         return Promise.reject(stream.@storedError);
     280        return @Promise.reject(stream.@storedError);
    281281    stream.@queue = @newQueue();
    282282    @finishClosingReadableStream(stream);
    … …  
    355355
    356356    if (reader.@state === @streamClosed)
    357         return Promise.resolve({value: undefined, done: true});
     357        return @Promise.resolve({value: undefined, done: true});
    358358    if (reader.@state === @streamErrored)
    359         return Promise.reject(reader.@storedError);
     359        return @Promise.reject(reader.@storedError);
    360360    // FIXME: ASSERT(!!reader.@ownerReadableStream);
    361361    // FIXME: ASSERT(reader.@ownerReadableStream.@state === @streamReadable);
    … …  
    367367        else if (!stream.@queue.content.length)
    368368            @finishClosingReadableStream(stream);
    369         return Promise.resolve({value: chunk, done: false});
    370     }
    371     var readPromiseCapability = @newPromiseCapability(Promise);
     369        return @Promise.resolve({value: chunk, done: false});
     370    }
     371    var readPromiseCapability = @newPromiseCapability(@Promise);
    372372    reader.@readRequests.push(readPromiseCapability);
    373373    @requestReadableStreamPull(stream);

  • trunk/Source/WebCore/Modules/streams/ReadableStreamReader.js

    r191950 r192021  
    3131
    3232    if (!@isReadableStreamReader(this))
    33         return Promise.reject(new @TypeError("Function should be called on a ReadableStreamReader"));
     33        return @Promise.reject(new @TypeError("Function should be called on a ReadableStreamReader"));
    3434
    3535    if (this.@state === @streamClosed)
    36         return Promise.resolve();
     36        return @Promise.resolve();
    3737
    3838    if (this.@state === @streamErrored)
    39         return Promise.reject(this.@storedError);
     39        return @Promise.reject(this.@storedError);
    4040
    4141    // FIXME: ASSERT(@isReadableStream(this.@ownerReadableStream));
    … …  
    4949
    5050    if (!@isReadableStreamReader(this))
    51         return Promise.reject(new @TypeError("Function should be called on a ReadableStreamReader"));
     51        return @Promise.reject(new @TypeError("Function should be called on a ReadableStreamReader"));
    5252
    5353    return @readFromReadableStreamReader(this);
    … …  
    7575
    7676    if (!@isReadableStreamReader(this))
    77         return Promise.reject(new @TypeError("Callee of closed is not a ReadableStreamReader"));
     77        return @Promise.reject(new @TypeError("Callee of closed is not a ReadableStreamReader"));
    7878
    7979    return this.@closedPromiseCapability.@promise;

  • trunk/Source/WebCore/Modules/streams/StreamInternals.js

    r191950 r192021  
    4545        var method = object[key];
    4646        if (typeof method === "undefined")
    47             return Promise.resolve();
     47            return @Promise.resolve();
    4848        var result = method.@apply(object, args);
    49         return Promise.resolve(result);
     49        return @Promise.resolve(result);
    5050    }
    5151    catch(error) {
    52         return Promise.reject(error);
     52        return @Promise.reject(error);
    5353    }
    5454
    … …  
    6464            return @promiseInvokeOrNoop(object, key2, args2);
    6565        const result = method.@apply(object, args1);
    66         return Promise.resolve(result);
     66        return @Promise.resolve(result);
    6767    }
    6868    catch(error) {
    69         return Promise.reject(error);
     69        return @Promise.reject(error);
    7070    }
    7171}

  • trunk/Source/WebCore/Modules/streams/WritableStream.js

    r191956 r192021  
    4343
    4444    this.@underlyingSink = underlyingSink;
    45     this.@closedPromiseCapability = @newPromiseCapability(Promise);
    46     this.@readyPromiseCapability = { @promise: Promise.resolve(undefined) };
     45    this.@closedPromiseCapability = @newPromiseCapability(@Promise);
     46    this.@readyPromiseCapability = { @promise: @Promise.resolve(undefined) };
    4747    this.@queue = @newQueue();
    4848    this.@state = @streamWritable;
    … …  
    5656    var error = @errorWritableStream.bind(this);
    5757    var startResult = @invokeOrNoop(underlyingSink, "start", [error]);
    58     this.@startedPromise = Promise.resolve(startResult);
     58    this.@startedPromise = @Promise.resolve(startResult);
    5959    var _this = this;
    6060    this.@startedPromise.then(function() {
    … …  
    7171
    7272    if (!@isWritableStream(this))
    73         return Promise.reject(new @TypeError("The WritableStream.abort method can only be used on instances of WritableStream"));
     73        return @Promise.reject(new @TypeError("The WritableStream.abort method can only be used on instances of WritableStream"));
    7474
    7575    if (this.@state === @streamClosed)
    76         return Promise.resolve(undefined);
     76        return @Promise.resolve(undefined);
    7777
    7878    if (this.@state === @streamErrored)
    79         return Promise.reject(this.@storedError);
     79        return @Promise.reject(this.@storedError);
    8080
    8181    @errorWritableStream.@apply(this, [reason]);
    … …  
    9191
    9292    if (!@isWritableStream(this))
    93         return Promise.reject(new @TypeError("The WritableStream.close method can only be used on instances of WritableStream"));
     93        return @Promise.reject(new @TypeError("The WritableStream.close method can only be used on instances of WritableStream"));
    9494
    9595    if (this.@state === @streamClosed || this.@state === @streamClosing)
    96         return Promise.reject(new @TypeError("Cannot close a WritableString that is closed or closing"));
     96        return @Promise.reject(new @TypeError("Cannot close a WritableString that is closed or closing"));
    9797
    9898    if (this.@state === @streamErrored)
    99         return Promise.reject(this.@storedError);
     99        return @Promise.reject(this.@storedError);
    100100
    101101    if (this.@state === @streamWaiting)
    … …  
    114114
    115115    if (!@isWritableStream(this))
    116         return Promise.reject(new @TypeError("The WritableStream.close method can only be used on instances of WritableStream"));
     116        return @Promise.reject(new @TypeError("The WritableStream.close method can only be used on instances of WritableStream"));
    117117
    118118    if (this.@state === @streamClosed || this.@state === @streamClosing)
    119         return Promise.reject(new @TypeError("Cannot write on a WritableString that is closed or closing"));
     119        return @Promise.reject(new @TypeError("Cannot write on a WritableString that is closed or closing"));
    120120
    121121    if (this.@state === @streamErrored)
    122         return Promise.reject(this.@storedError);
     122        return @Promise.reject(this.@storedError);
    123123
    124124    // FIXME
    … …  
    131131        } catch(e) {
    132132            @errorWritableStream.@call(this, e);
    133             return Promise.reject(e);
     133            return @Promise.reject(e);
    134134        }
    135135    }
    136136
    137     const promiseCapability = @newPromiseCapability(Promise);
     137    const promiseCapability = @newPromiseCapability(@Promise);
    138138    try {
    139139        @enqueueValueWithSize(this.@queue, { promiseCapability: promiseCapability, chunk: chunk }, chunkSize);
    140140    } catch (e) {
    141141        @errorWritableStream.@call(this, e);
    142         return Promise.reject(e);
     142        return @Promise.reject(e);
    143143    }
    144144
    … …  
    154154
    155155    if (!@isWritableStream(this))
    156         return Promise.reject(new @TypeError("The WritableStream.closed getter can only be used on instances of WritableStream"));
     156        return @Promise.reject(new @TypeError("The WritableStream.closed getter can only be used on instances of WritableStream"));
    157157
    158158    return this.@closedPromiseCapability.@promise;
    … …  
    164164
    165165    if (!@isWritableStream(this))
    166         return Promise.reject(new @TypeError("The WritableStream.ready getter can only be used on instances of WritableStream"));
     166        return @Promise.reject(new @TypeError("The WritableStream.ready getter can only be used on instances of WritableStream"));
    167167
    168168    return this.@readyPromiseCapability.@promise;

  • trunk/Source/WebCore/Modules/streams/WritableStreamInternals.js

    r191956 r192021  
    4848    if (shouldApplyBackpressure && stream.@state === @streamWritable) {
    4949        stream.@state = @streamWaiting;
    50         stream.@readyPromiseCapability = @newPromiseCapability(Promise);
     50        stream.@readyPromiseCapability = @newPromiseCapability(@Promise);
    5151    }
    5252    if (!shouldApplyBackpressure && stream.@state === @streamWaiting) {
Note: See TracChangeset for help on using the changeset viewer.