Changeset 230637 in webkit


Ignore:
Timestamp:
Apr 13, 2018 10:01:40 AM (6 years ago)
Author:
Yusuke Suzuki
Message:

[WebCore] Use @getByIdDirectPrivate / @putByIdDirectPrivate in WebCore JS
​https://bugs.webkit.org/show_bug.cgi?id=184401

Rubber stamped by Saam Barati.

Apply bug 183970 changes to WebCore JS too. This offers solid type checking
with @getByIdDirectPrivate().

  • Modules/mediastream/RTCPeerConnection.js:

(initializeRTCPeerConnection):
(getLocalStreams):
(getStreamById):
(addStream):

  • Modules/mediastream/RTCPeerConnectionInternals.js:

(isRTCPeerConnection):

  • Modules/streams/ReadableByteStreamController.js:

(enqueue):
(error):
(close):
(getter.byobRequest):

  • Modules/streams/ReadableByteStreamInternals.js:

(privateInitializeReadableStreamBYOBReader):
(privateInitializeReadableByteStreamController):
(privateInitializeReadableStreamBYOBRequest):
(isReadableByteStreamController):
(isReadableStreamBYOBRequest):
(isReadableStreamBYOBReader):
(readableByteStreamControllerCancel):
(readableByteStreamControllerError):
(readableByteStreamControllerClose):
(readableByteStreamControllerClearPendingPullIntos):
(readableByteStreamControllerGetDesiredSize):
(readableStreamHasBYOBReader):
(readableStreamHasDefaultReader):
(readableByteStreamControllerHandleQueueDrain):
(readableByteStreamControllerPull):
(readableByteStreamControllerShouldCallPull):
(readableByteStreamControllerCallPullIfNeeded):
(readableByteStreamControllerEnqueue):
(readableByteStreamControllerEnqueueChunk):
(readableByteStreamControllerRespondWithNewView):
(readableByteStreamControllerRespond):
(readableByteStreamControllerRespondInternal):
(readableByteStreamControllerRespondInReadableState):
(readableByteStreamControllerRespondInClosedState):
(readableByteStreamControllerProcessPullDescriptors):
(readableByteStreamControllerFillDescriptorFromQueue):
(readableByteStreamControllerShiftPendingDescriptor):
(readableByteStreamControllerInvalidateBYOBRequest):
(readableByteStreamControllerCommitDescriptor):
(readableStreamFulfillReadIntoRequest):
(readableByteStreamControllerPullInto):
(readableStreamAddReadIntoRequest):

  • Modules/streams/ReadableStream.js:

(initializeReadableStream):
(pipeThrough):

  • Modules/streams/ReadableStreamBYOBReader.js:

(cancel):
(read):
(releaseLock):
(getter.closed):

  • Modules/streams/ReadableStreamBYOBRequest.js:

(respond):
(respondWithNewView):
(getter.view):

  • Modules/streams/ReadableStreamDefaultController.js:

(error):

  • Modules/streams/ReadableStreamDefaultReader.js:

(cancel):
(read):
(releaseLock):
(getter.closed):

  • Modules/streams/ReadableStreamInternals.js:

(privateInitializeReadableStreamDefaultReader):
(readableStreamReaderGenericInitialize):
(readableStreamDefaultControllerError):
(readableStreamPipeTo):
(readableStreamTee):
(isReadableStream):
(isReadableStreamDefaultReader):
(isReadableStreamDefaultController):
(readableStreamError):
(readableStreamDefaultControllerCallPullIfNeeded):
(readableStreamDefaultControllerGetDesiredSize):
(readableStreamReaderGenericCancel):
(readableStreamCancel):
(readableStreamDefaultControllerCancel):
(readableStreamDefaultControllerPull):
(readableStreamDefaultControllerClose):
(readableStreamClose):
(readableStreamFulfillReadRequest):
(readableStreamDefaultReaderRead):
(readableStreamAddReadRequest):
(isReadableStreamDisturbed):
(readableStreamReaderGenericRelease):
(readableStreamDefaultControllerCanCloseOrEnqueue):
(privateInitializeReadableStreamDefaultController): Deleted.

  • Modules/streams/StreamInternals.js:

(validateAndNormalizeQueuingStrategy):

  • Modules/streams/WritableStream.js:

(initializeWritableStream):
(abort):
(close):
(write):
(getter.closed):
(getter.ready):
(getter.state):

  • Modules/streams/WritableStreamInternals.js:

(isWritableStream):
(syncWritableStreamStateWithQueue):
(errorWritableStream):
(callOrScheduleWritableStreamAdvanceQueue):

  • bindings/js/JSDOMBindingInternals.js:

(mapLikeForEach):

Location:
trunk/Source/WebCore
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r230632 r230637  
     12018-04-13  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [WebCore] Use @getByIdDirectPrivate / @putByIdDirectPrivate in WebCore JS
     4        https://bugs.webkit.org/show_bug.cgi?id=184401
     5
     6        Rubber stamped by Saam Barati.
     7
     8        Apply bug 183970 changes to WebCore JS too. This offers solid type checking
     9        with @getByIdDirectPrivate().
     10
     11        * Modules/mediastream/RTCPeerConnection.js:
     12        (initializeRTCPeerConnection):
     13        (getLocalStreams):
     14        (getStreamById):
     15        (addStream):
     16        * Modules/mediastream/RTCPeerConnectionInternals.js:
     17        (isRTCPeerConnection):
     18        * Modules/streams/ReadableByteStreamController.js:
     19        (enqueue):
     20        (error):
     21        (close):
     22        (getter.byobRequest):
     23        * Modules/streams/ReadableByteStreamInternals.js:
     24        (privateInitializeReadableStreamBYOBReader):
     25        (privateInitializeReadableByteStreamController):
     26        (privateInitializeReadableStreamBYOBRequest):
     27        (isReadableByteStreamController):
     28        (isReadableStreamBYOBRequest):
     29        (isReadableStreamBYOBReader):
     30        (readableByteStreamControllerCancel):
     31        (readableByteStreamControllerError):
     32        (readableByteStreamControllerClose):
     33        (readableByteStreamControllerClearPendingPullIntos):
     34        (readableByteStreamControllerGetDesiredSize):
     35        (readableStreamHasBYOBReader):
     36        (readableStreamHasDefaultReader):
     37        (readableByteStreamControllerHandleQueueDrain):
     38        (readableByteStreamControllerPull):
     39        (readableByteStreamControllerShouldCallPull):
     40        (readableByteStreamControllerCallPullIfNeeded):
     41        (readableByteStreamControllerEnqueue):
     42        (readableByteStreamControllerEnqueueChunk):
     43        (readableByteStreamControllerRespondWithNewView):
     44        (readableByteStreamControllerRespond):
     45        (readableByteStreamControllerRespondInternal):
     46        (readableByteStreamControllerRespondInReadableState):
     47        (readableByteStreamControllerRespondInClosedState):
     48        (readableByteStreamControllerProcessPullDescriptors):
     49        (readableByteStreamControllerFillDescriptorFromQueue):
     50        (readableByteStreamControllerShiftPendingDescriptor):
     51        (readableByteStreamControllerInvalidateBYOBRequest):
     52        (readableByteStreamControllerCommitDescriptor):
     53        (readableStreamFulfillReadIntoRequest):
     54        (readableByteStreamControllerPullInto):
     55        (readableStreamAddReadIntoRequest):
     56        * Modules/streams/ReadableStream.js:
     57        (initializeReadableStream):
     58        (pipeThrough):
     59        * Modules/streams/ReadableStreamBYOBReader.js:
     60        (cancel):
     61        (read):
     62        (releaseLock):
     63        (getter.closed):
     64        * Modules/streams/ReadableStreamBYOBRequest.js:
     65        (respond):
     66        (respondWithNewView):
     67        (getter.view):
     68        * Modules/streams/ReadableStreamDefaultController.js:
     69        (error):
     70        * Modules/streams/ReadableStreamDefaultReader.js:
     71        (cancel):
     72        (read):
     73        (releaseLock):
     74        (getter.closed):
     75        * Modules/streams/ReadableStreamInternals.js:
     76        (privateInitializeReadableStreamDefaultReader):
     77        (readableStreamReaderGenericInitialize):
     78        (readableStreamDefaultControllerError):
     79        (readableStreamPipeTo):
     80        (readableStreamTee):
     81        (isReadableStream):
     82        (isReadableStreamDefaultReader):
     83        (isReadableStreamDefaultController):
     84        (readableStreamError):
     85        (readableStreamDefaultControllerCallPullIfNeeded):
     86        (readableStreamDefaultControllerGetDesiredSize):
     87        (readableStreamReaderGenericCancel):
     88        (readableStreamCancel):
     89        (readableStreamDefaultControllerCancel):
     90        (readableStreamDefaultControllerPull):
     91        (readableStreamDefaultControllerClose):
     92        (readableStreamClose):
     93        (readableStreamFulfillReadRequest):
     94        (readableStreamDefaultReaderRead):
     95        (readableStreamAddReadRequest):
     96        (isReadableStreamDisturbed):
     97        (readableStreamReaderGenericRelease):
     98        (readableStreamDefaultControllerCanCloseOrEnqueue):
     99        (privateInitializeReadableStreamDefaultController): Deleted.
     100        * Modules/streams/StreamInternals.js:
     101        (validateAndNormalizeQueuingStrategy):
     102        * Modules/streams/WritableStream.js:
     103        (initializeWritableStream):
     104        (abort):
     105        (close):
     106        (write):
     107        (getter.closed):
     108        (getter.ready):
     109        (getter.state):
     110        * Modules/streams/WritableStreamInternals.js:
     111        (isWritableStream):
     112        (syncWritableStreamStateWithQueue):
     113        (errorWritableStream):
     114        (callOrScheduleWritableStreamAdvanceQueue):
     115        * bindings/js/JSDOMBindingInternals.js:
     116        (mapLikeForEach):
     117
    11182018-04-12  Antoine Quint  <graouts@apple.com>
    2119

  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.js

    r229645 r230637  
    4141
    4242    this.@initializeWith(configuration);
    43     this.@operations = [];
    44     this.@localStreams = [];
     43    @putByIdDirectPrivate(this, "operations", []);
     44    @putByIdDirectPrivate(this, "localStreams", []);
    4545
    4646    return this;
    … …  
    5454        throw @makeThisTypeError("RTCPeerConnection", "getLocalStreams");
    5555
    56     return this.@localStreams.slice();
     56    return @getByIdDirectPrivate(this, "localStreams").slice();
    5757}
    5858
    … …  
    6767        @throwTypeError("Not enough arguments");
    6868
    69     const streamId = @String(streamIdArg);
    70 
    71     return this.@localStreams.find(stream => stream.id === streamId)
     69    const streamId = @toString(streamIdArg);
     70
     71    return @getByIdDirectPrivate(this, "localStreams").find(stream => stream.id === streamId)
    7272        || this.@getRemoteStreams().find(stream => stream.id === streamId)
    7373        || null;
    … …  
    8787        @throwTypeError("Argument 1 ('stream') to RTCPeerConnection.addStream must be an instance of MediaStream");
    8888
    89     if (this.@localStreams.find(localStream => localStream.id === stream.id))
     89    if (@getByIdDirectPrivate(this, "localStreams").find(localStream => localStream.id === stream.id))
    9090        return;
    9191
    92     this.@localStreams.@push(stream);
     92    @getByIdDirectPrivate(this, "localStreams").@push(stream);
    9393    stream.@getTracks().forEach(track => this.@addTrack(track, stream));
    9494}
    … …  
    107107        @throwTypeError("Argument 1 ('stream') to RTCPeerConnection.removeStream must be an instance of MediaStream");
    108108
    109     const indexOfStreamToRemove = this.@localStreams.findIndex(localStream => localStream.id === stream.id);
     109    const indexOfStreamToRemove = @getByIdDirectPrivate(this, "localStreams").findIndex(localStream => localStream.id === stream.id);
    110110    if (indexOfStreamToRemove === -1)
    111111        return;
    112112
    113113    const senders = this.@getSenders();
    114     this.@localStreams[indexOfStreamToRemove].@getTracks().forEach(track => {
     114    @getByIdDirectPrivate(this, "localStreams")[indexOfStreamToRemove].@getTracks().forEach(track => {
    115115        const senderForTrack = senders.find(sender => sender.track && sender.track.id === track.id);
    116116        if (senderForTrack)
    … …  
    118118    });
    119119
    120     this.@localStreams.splice(indexOfStreamToRemove, 1);
     120    @getByIdDirectPrivate(this, "localStreams").splice(indexOfStreamToRemove, 1);
    121121}
    122122

  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnectionInternals.js

    r214527 r230637  
    3737    "use strict";
    3838
    39     const operations = peerConnection.@operations;
     39    const operations = @getByIdDirectPrivate(peerConnection, "operations");
    4040
    4141    function runNext() {
    … …  
    134134    "use strict";
    135135
    136     return @isObject(connection) && !!connection.@operations;
     136    return @isObject(connection) && !!@getByIdDirectPrivate(connection, "operations");
    137137}

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

    r221417 r230637  
    3333        throw @makeThisTypeError("ReadableByteStreamController", "enqueue");
    3434
    35     if (this.@closeRequested)
     35    if (@getByIdDirectPrivate(this, "closeRequested"))
    3636        @throwTypeError("ReadableByteStreamController is requested to close");
    3737
    38     if (this.@controlledReadableStream.@state !== @streamReadable)
     38    if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
    3939        @throwTypeError("ReadableStream is not readable");
    4040
    … …  
    5555        throw @makeThisTypeError("ReadableByteStreamController", "error");
    5656
    57     if (this.@controlledReadableStream.@state !== @streamReadable)
     57    if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
    5858        @throwTypeError("ReadableStream is not readable");
    5959
    … …  
    6868        throw @makeThisTypeError("ReadableByteStreamController", "close");
    6969
    70     if (this.@closeRequested)
     70    if (@getByIdDirectPrivate(this, "closeRequested"))
    7171        @throwTypeError("Close has already been requested");
    7272
    73     if (this.@controlledReadableStream.@state !== @streamReadable)
     73    if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
    7474        @throwTypeError("ReadableStream is not readable");
    7575
    … …  
    8585        throw @makeGetterTypeError("ReadableByteStreamController", "byobRequest");
    8686
    87     if (this.@byobRequest === @undefined && this.@pendingPullIntos.length) {
    88         const firstDescriptor = this.@pendingPullIntos[0];
     87    if (@getByIdDirectPrivate(this, "byobRequest") === @undefined && @getByIdDirectPrivate(this, "pendingPullIntos").length) {
     88        const firstDescriptor = @getByIdDirectPrivate(this, "pendingPullIntos")[0];
    8989        const view = new @Uint8Array(firstDescriptor.buffer,
    9090            firstDescriptor.byteOffset + firstDescriptor.bytesFilled,
    9191            firstDescriptor.byteLength - firstDescriptor.bytesFilled);
    92         this.@byobRequest = new @ReadableStreamBYOBRequest(this, view);
     92        @putByIdDirectPrivate(this, "byobRequest", new @ReadableStreamBYOBRequest(this, view));
    9393    }
    9494
    95     return this.@byobRequest;
     95    return @getByIdDirectPrivate(this, "byobRequest");
    9696}
    9797

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

    r226005 r230637  
    3333    if (!@isReadableStream(stream))
    3434        @throwTypeError("ReadableStreamBYOBReader needs a ReadableStream");
    35     if (!@isReadableByteStreamController(stream.@readableStreamController))
     35    if (!@isReadableByteStreamController(@getByIdDirectPrivate(stream, "readableStreamController")))
    3636        @throwTypeError("ReadableStreamBYOBReader needs a ReadableByteStreamController");
    3737    if (@isReadableStreamLocked(stream))
    … …  
    3939
    4040    @readableStreamReaderGenericInitialize(this, stream);
    41     this.@readIntoRequests = [];
     41    @putByIdDirectPrivate(this, "readIntoRequests", []);
    4242
    4343    return this;
    … …  
    5252
    5353    // readableStreamController is initialized with null value.
    54     if (stream.@readableStreamController !== null)
     54    if (@getByIdDirectPrivate(stream, "readableStreamController") !== null)
    5555        @throwTypeError("ReadableStream already has a controller");
    5656
    57     this.@controlledReadableStream = stream;
    58     this.@underlyingByteSource = underlyingByteSource;
    59     this.@pullAgain = false;
    60     this.@pulling = false;
     57    @putByIdDirectPrivate(this, "controlledReadableStream", stream);
     58    @putByIdDirectPrivate(this, "underlyingByteSource", underlyingByteSource);
     59    @putByIdDirectPrivate(this, "pullAgain", false);
     60    @putByIdDirectPrivate(this, "pulling", false);
    6161    @readableByteStreamControllerClearPendingPullIntos(this);
    62     this.@queue = @newQueue();
    63     this.@started = false;
    64     this.@closeRequested = false;
     62    @putByIdDirectPrivate(this, "queue", @newQueue());
     63    @putByIdDirectPrivate(this, "started", false);
     64    @putByIdDirectPrivate(this, "closeRequested", false);
    6565
    6666    let hwm = @toNumber(highWaterMark);
    6767    if (@isNaN(hwm) || hwm < 0)
    6868        @throwRangeError("highWaterMark value is negative or not a number");
    69     this.@strategyHWM = hwm;
     69    @putByIdDirectPrivate(this, "strategyHWM", hwm);
    7070
    7171    let autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
    … …  
    7575            @throwRangeError("autoAllocateChunkSize value is negative or equal to positive or negative infinity");
    7676    }
    77     this.@autoAllocateChunkSize = autoAllocateChunkSize;
    78     this.@pendingPullIntos = [];
     77    @putByIdDirectPrivate(this, "autoAllocateChunkSize", autoAllocateChunkSize);
     78    @putByIdDirectPrivate(this, "pendingPullIntos", []);
    7979
    8080    const controller = this;
    8181    const startResult = @promiseInvokeOrNoopNoCatch(underlyingByteSource, "start", [this]).@then(() => {
    82         controller.@started = true;
    83         @assert(!controller.@pulling);
    84         @assert(!controller.@pullAgain);
     82        @putByIdDirectPrivate(controller, "started", true);
     83        @assert(!@getByIdDirectPrivate(controller, "pulling"));
     84        @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
    8585        @readableByteStreamControllerCallPullIfNeeded(controller);
    8686    }, (error) => {
    87         if (stream.@state === @streamReadable)
     87        if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
    8888            @readableByteStreamControllerError(controller, error);
    8989    });
    9090
    91     this.@cancel = @readableByteStreamControllerCancel;
    92     this.@pull = @readableByteStreamControllerPull;
     91    @putByIdDirectPrivate(this, "cancel", @readableByteStreamControllerCancel);
     92    @putByIdDirectPrivate(this, "pull", @readableByteStreamControllerPull);
    9393
    9494    return this;
    … …  
    9999    "use strict";
    100100
    101     this.@associatedReadableByteStreamController = controller;
    102     this.@view = view;
     101    @putByIdDirectPrivate(this, "associatedReadableByteStreamController", controller);
     102    @putByIdDirectPrivate(this, "view", view);
    103103}
    104104
    … …  
    109109    // Same test mechanism as in isReadableStreamDefaultController (ReadableStreamInternals.js).
    110110    // See corresponding function for explanations.
    111     return @isObject(controller) && !!controller.@underlyingByteSource;
     111    return @isObject(controller) && !!@getByIdDirectPrivate(controller, "underlyingByteSource");
    112112}
    113113
    … …  
    118118    // Same test mechanism as in isReadableStreamDefaultController (ReadableStreamInternals.js).
    119119    // See corresponding function for explanations.
    120     return @isObject(byobRequest) && !!byobRequest.@associatedReadableByteStreamController;
     120    return @isObject(byobRequest) && !!@getByIdDirectPrivate(byobRequest, "associatedReadableByteStreamController");
    121121}
    122122
    … …  
    128128    // However, since it is a private slot, it cannot be checked using hasOwnProperty().
    129129    // Since readIntoRequests is initialized with an empty array, the following test is ok.
    130     return @isObject(reader) && !!reader.@readIntoRequests;
     130    return @isObject(reader) && !!@getByIdDirectPrivate(reader, "readIntoRequests");
    131131}
    132132
    … …  
    135135    "use strict";
    136136
    137     if (controller.@pendingPullIntos.length > 0)
    138         controller.@pendingPullIntos[0].bytesFilled = 0;
    139     controller.@queue = @newQueue();
    140     return @promiseInvokeOrNoop(controller.@underlyingByteSource, "cancel", [reason]);
     137    var pendingPullIntos = @getByIdDirectPrivate(controller, "pendingPullIntos");
     138    if (pendingPullIntos.length > 0)
     139        pendingPullIntos[0].bytesFilled = 0;
     140    @putByIdDirectPrivate(controller, "queue", @newQueue());
     141    return @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingByteSource"), "cancel", [reason]);
    141142}
    142143
    … …  
    145146    "use strict";
    146147
    147     @assert(controller.@controlledReadableStream.@state === @streamReadable);
     148    @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable);
    148149    @readableByteStreamControllerClearPendingPullIntos(controller);
    149     controller.@queue = @newQueue();
    150     @readableStreamError(controller.@controlledReadableStream, e);
     150    @putByIdDirectPrivate(controller, "queue", @newQueue());
     151    @readableStreamError(@getByIdDirectPrivate(controller, "controlledReadableStream"), e);
    151152}
    152153
    … …  
    155156    "use strict";
    156157
    157     @assert(!controller.@closeRequested);
    158     @assert(controller.@controlledReadableStream.@state === @streamReadable);
    159 
    160     if (controller.@queue.size > 0) {
    161         controller.@closeRequested = true;
     158    @assert(!@getByIdDirectPrivate(controller, "closeRequested"));
     159    @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable);
     160
     161    if (@getByIdDirectPrivate(controller, "queue").size > 0) {
     162        @putByIdDirectPrivate(controller, "closeRequested", true);
    162163        return;
    163164    }
    164165
    165     if (controller.@pendingPullIntos.length > 0) {
    166         if (controller.@pendingPullIntos[0].bytesFilled > 0) {
     166    var pendingPullIntos = @getByIdDirectPrivate(controller, "pendingPullIntos");
     167    if (pendingPullIntos.length > 0) {
     168        if (pendingPullIntos[0].bytesFilled > 0) {
    167169            const e = new @TypeError("Close requested while there remain pending bytes");
    168170            @readableByteStreamControllerError(controller, e);
    … …  
    171173    }
    172174
    173     @readableStreamClose(controller.@controlledReadableStream);
     175    @readableStreamClose(@getByIdDirectPrivate(controller, "controlledReadableStream"));
    174176}
    175177
    … …  
    179181
    180182    @readableByteStreamControllerInvalidateBYOBRequest(controller);
    181     controller.@pendingPullIntos = [];
     183    @putByIdDirectPrivate(controller, "pendingPullIntos", []);
    182184}
    183185
    184186function readableByteStreamControllerGetDesiredSize(controller)
    185187{
    186    "use strict";
    187 
    188    const stream = controller.@controlledReadableStream;
    189 
    190    if (stream.@state === @streamErrored)
    191        return null;
    192    if (stream.@state === @streamClosed)
    193        return 0;
    194 
    195    return controller.@strategyHWM - controller.@queue.size;
     188    "use strict";
     189
     190    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
     191    const state = @getByIdDirectPrivate(stream, "state");
     192
     193    if (state === @streamErrored)
     194        return null;
     195    if (state === @streamClosed)
     196        return 0;
     197
     198    return @getByIdDirectPrivate(controller, "strategyHWM") - @getByIdDirectPrivate(controller, "queue").size;
    196199}
    197200
    … …  
    200203    "use strict";
    201204
    202     return stream.@reader !== @undefined && @isReadableStreamBYOBReader(stream.@reader);
     205    const reader = @getByIdDirectPrivate(stream, "reader");
     206    return reader !== @undefined && @isReadableStreamBYOBReader(reader);
    203207}
    204208
    … …  
    207211    "use strict";
    208212
    209     return stream.@reader !== @undefined && @isReadableStreamDefaultReader(stream.@reader);
     213    const reader = @getByIdDirectPrivate(stream, "reader");
     214    return reader !== @undefined && @isReadableStreamDefaultReader(reader);
    210215}
    211216
    … …  
    214219    "use strict";
    215220
    216     @assert(controller.@controlledReadableStream.@state === @streamReadable);
    217     if (!controller.@queue.size && controller.@closeRequested)
    218         @readableStreamClose(controller.@controlledReadableStream);
     221    @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable);
     222    if (!@getByIdDirectPrivate(controller, "queue").size && @getByIdDirectPrivate(controller, "closeRequested"))
     223        @readableStreamClose(@getByIdDirectPrivate(controller, "controlledReadableStream"));
    219224    else
    220225        @readableByteStreamControllerCallPullIfNeeded(controller);
    … …  
    225230    "use strict";
    226231
    227     const stream = controller.@controlledReadableStream;
     232    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
    228233    @assert(@readableStreamHasDefaultReader(stream));
    229234
    230     if (controller.@queue.size > 0) {
    231         @assert(stream.@reader.@readRequests.length === 0);
    232         const entry = controller.@queue.content.@shift();
    233         controller.@queue.size -= entry.byteLength;
     235    if (@getByIdDirectPrivate(controller, "queue").size > 0) {
     236        @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length === 0);
     237        const entry = @getByIdDirectPrivate(controller, "queue").content.@shift();
     238        @getByIdDirectPrivate(controller, "queue").size -= entry.byteLength;
    234239        @readableByteStreamControllerHandleQueueDrain(controller);
    235240        let view;
    … …  
    242247    }
    243248
    244     if (controller.@autoAllocateChunkSize !== @undefined) {
     249    if (@getByIdDirectPrivate(controller, "autoAllocateChunkSize") !== @undefined) {
    245250        let buffer;
    246251        try {
    247             buffer = new @ArrayBuffer(controller.@autoAllocateChunkSize);
     252            buffer = new @ArrayBuffer(@getByIdDirectPrivate(controller, "autoAllocateChunkSize"));
    248253        } catch (error) {
    249254            return @Promise.@reject(error);
    … …  
    252257            buffer,
    253258            byteOffset: 0,
    254             byteLength: controller.@autoAllocateChunkSize,
     259            byteLength: @getByIdDirectPrivate(controller, "autoAllocateChunkSize"),
    255260            bytesFilled: 0,
    256261            elementSize: 1,
    … …  
    258263            readerType: 'default'
    259264        };
    260         controller.@pendingPullIntos.@push(pullIntoDescriptor);
     265        @getByIdDirectPrivate(controller, "pendingPullIntos").@push(pullIntoDescriptor);
    261266    }
    262267
    … …  
    270275    "use strict";
    271276
    272     const stream = controller.@controlledReadableStream;
    273 
    274     if (stream.@state !== @streamReadable)
     277    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
     278
     279    if (@getByIdDirectPrivate(stream, "state") !== @streamReadable)
    275280        return false;
    276     if (controller.@closeRequested)
     281    if (@getByIdDirectPrivate(controller, "closeRequested"))
    277282        return false;
    278     if (!controller.@started)
     283    if (!@getByIdDirectPrivate(controller, "started"))
    279284        return false;
    280     if (@readableStreamHasDefaultReader(stream) && stream.@reader.@readRequests.length > 0)
     285    if (@readableStreamHasDefaultReader(stream) && @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length > 0)
    281286        return true;
    282     if (@readableStreamHasBYOBReader(stream) && stream.@reader.@readIntoRequests.length > 0)
     287    if (@readableStreamHasBYOBReader(stream) && @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readIntoRequests").length > 0)
    283288        return true;
    284289    if (@readableByteStreamControllerGetDesiredSize(controller) > 0)
    … …  
    294299        return;
    295300
    296     if (controller.@pulling) {
    297         controller.@pullAgain = true;
     301    if (@getByIdDirectPrivate(controller, "pulling")) {
     302        @putByIdDirectPrivate(controller, "pullAgain", true);
    298303        return;
    299304    }
    300305
    301     @assert(!controller.@pullAgain);
    302     controller.@pulling = true;
    303     @promiseInvokeOrNoop(controller.@underlyingByteSource, "pull", [controller]).@then(() => {
    304         controller.@pulling = false;
    305         if (controller.@pullAgain) {
    306             controller.@pullAgain = false;
     306    @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
     307    @putByIdDirectPrivate(controller, "pulling", true);
     308    @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingByteSource"), "pull", [controller]).@then(() => {
     309        @putByIdDirectPrivate(controller, "pulling", false);
     310        if (@getByIdDirectPrivate(controller, "pullAgain")) {
     311            @putByIdDirectPrivate(controller, "pullAgain", false);
    307312            @readableByteStreamControllerCallPullIfNeeded(controller);
    308313        }
    309314    }, (error) => {
    310         if (controller.@controlledReadableStream.@state === @streamReadable)
     315        if (@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable)
    311316            @readableByteStreamControllerError(controller, error);
    312317    });
    … …  
    328333    "use strict";
    329334
    330     const stream = controller.@controlledReadableStream;
    331     @assert(!controller.@closeRequested);
    332     @assert(stream.@state === @streamReadable);
     335    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
     336    @assert(!@getByIdDirectPrivate(controller, "closeRequested"));
     337    @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
    333338    const buffer = chunk.buffer;
    334339    const byteOffset = chunk.byteOffset;
    … …  
    337342
    338343    if (@readableStreamHasDefaultReader(stream)) {
    339         if (!stream.@reader.@readRequests.length)
     344        if (!@getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length)
    340345            @readableByteStreamControllerEnqueueChunk(controller, transferredBuffer, byteOffset, byteLength);
    341346        else {
    342             @assert(!controller.@queue.content.length);
     347            @assert(!@getByIdDirectPrivate(controller, "queue").content.length);
    343348            let transferredView = new @Uint8Array(transferredBuffer, byteOffset, byteLength);
    344349            @readableStreamFulfillReadRequest(stream, transferredView, false);
    … …  
    362367    "use strict";
    363368
    364     controller.@queue.content.@push({
     369    @getByIdDirectPrivate(controller, "queue").content.@push({
    365370        buffer: buffer,
    366371        byteOffset: byteOffset,
    367372        byteLength: byteLength
    368373    });
    369     controller.@queue.size += byteLength;
     374    @getByIdDirectPrivate(controller, "queue").size += byteLength;
    370375}
    371376
    … …  
    374379    "use strict";
    375380
    376     @assert(controller.@pendingPullIntos.length > 0);
    377 
    378     let firstDescriptor = controller.@pendingPullIntos[0];
     381    @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length > 0);
     382
     383    let firstDescriptor = @getByIdDirectPrivate(controller, "pendingPullIntos")[0];
    379384
    380385    if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset)
    … …  
    397402        @throwRangeError("bytesWritten has an incorrect value");
    398403
    399     @assert(controller.@pendingPullIntos.length > 0);
     404    @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length > 0);
    400405
    401406    @readableByteStreamControllerRespondInternal(controller, bytesWritten);
    … …  
    406411    "use strict";
    407412
    408     let firstDescriptor = controller.@pendingPullIntos[0];
    409     let stream = controller.@controlledReadableStream;
    410 
    411     if (stream.@state === @streamClosed) {
     413    let firstDescriptor = @getByIdDirectPrivate(controller, "pendingPullIntos")[0];
     414    let stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
     415
     416    if (@getByIdDirectPrivate(stream, "state") === @streamClosed) {
    412417        if (bytesWritten !== 0)
    413418            @throwTypeError("bytesWritten is different from 0 even though stream is closed");
    414419        @readableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
    415420    } else {
    416         @assert(stream.@state === @streamReadable);
     421        @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
    417422        @readableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
    418423    }
    … …  
    426431        @throwRangeError("bytesWritten value is too great");
    427432
    428     @assert(controller.@pendingPullIntos.length === 0 || controller.@pendingPullIntos[0] === pullIntoDescriptor);
     433    @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length === 0 || @getByIdDirectPrivate(controller, "pendingPullIntos")[0] === pullIntoDescriptor);
    429434    @readableByteStreamControllerInvalidateBYOBRequest(controller);
    430435    pullIntoDescriptor.bytesFilled += bytesWritten;
    … …  
    444449    pullIntoDescriptor.buffer = @transferBufferToCurrentRealm(pullIntoDescriptor.buffer);
    445450    pullIntoDescriptor.bytesFilled -= remainderSize;
    446     @readableByteStreamControllerCommitDescriptor(controller.@controlledReadableStream, pullIntoDescriptor);
     451    @readableByteStreamControllerCommitDescriptor(@getByIdDirectPrivate(controller, "controlledReadableStream"), pullIntoDescriptor);
    447452    @readableByteStreamControllerProcessPullDescriptors(controller);
    448453}
    … …  
    455460    @assert(firstDescriptor.bytesFilled === 0);
    456461
    457     if (@readableStreamHasBYOBReader(controller.@controlledReadableStream)) {
    458         while (controller.@controlledReadableStream.@reader.@readIntoRequests.length > 0) {
     462    if (@readableStreamHasBYOBReader(@getByIdDirectPrivate(controller, "controlledReadableStream"))) {
     463        while (@getByIdDirectPrivate(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "reader"), "readIntoRequests").length > 0) {
    459464            let pullIntoDescriptor = @readableByteStreamControllerShiftPendingDescriptor(controller);
    460             @readableByteStreamControllerCommitDescriptor(controller.@controlledReadableStream, pullIntoDescriptor);
     465            @readableByteStreamControllerCommitDescriptor(@getByIdDirectPrivate(controller, "controlledReadableStream"), pullIntoDescriptor);
    461466        }
    462467    }
    … …  
    468473    "use strict";
    469474
    470     @assert(!controller.@closeRequested);
    471     while (controller.@pendingPullIntos.length > 0) {
    472         if (controller.@queue.size === 0)
     475    @assert(!@getByIdDirectPrivate(controller, "closeRequested"));
     476    while (@getByIdDirectPrivate(controller, "pendingPullIntos").length > 0) {
     477        if (@getByIdDirectPrivate(controller, "queue").size === 0)
    473478            return;
    474         let pullIntoDescriptor = controller.@pendingPullIntos[0];
     479        let pullIntoDescriptor = @getByIdDirectPrivate(controller, "pendingPullIntos")[0];
    475480        if (@readableByteStreamControllerFillDescriptorFromQueue(controller, pullIntoDescriptor)) {
    476481            @readableByteStreamControllerShiftPendingDescriptor(controller);
    477             @readableByteStreamControllerCommitDescriptor(controller.@controlledReadableStream, pullIntoDescriptor);
     482            @readableByteStreamControllerCommitDescriptor(@getByIdDirectPrivate(controller, "controlledReadableStream"), pullIntoDescriptor);
    478483        }
    479484    }
    … …  
    486491
    487492    const currentAlignedBytes = pullIntoDescriptor.bytesFilled - (pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize);
    488     const maxBytesToCopy = controller.@queue.size < pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled ?
    489                 controller.@queue.size : pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled;
     493    const maxBytesToCopy = @getByIdDirectPrivate(controller, "queue").size < pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled ?
     494                @getByIdDirectPrivate(controller, "queue").size : pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled;
    490495    const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
    491496    const maxAlignedBytes = maxBytesFilled - (maxBytesFilled % pullIntoDescriptor.elementSize);
    … …  
    499504
    500505    while (totalBytesToCopyRemaining > 0) {
    501         let headOfQueue = controller.@queue.content[0];
     506        let headOfQueue = @getByIdDirectPrivate(controller, "queue").content[0];
    502507        const bytesToCopy = totalBytesToCopyRemaining < headOfQueue.byteLength ? totalBytesToCopyRemaining : headOfQueue.byteLength;
    503508        // Copy appropriate part of pullIntoDescriptor.buffer to headOfQueue.buffer.
    … …  
    510515
    511516        if (headOfQueue.byteLength === bytesToCopy)
    512             controller.@queue.content.@shift();
     517            @getByIdDirectPrivate(controller, "queue").content.@shift();
    513518        else {
    514519            headOfQueue.byteOffset += bytesToCopy;
    … …  
    516521        }
    517522
    518         controller.@queue.size -= bytesToCopy;
    519         @assert(controller.@pendingPullIntos.length === 0 || controller.@pendingPullIntos[0] === pullIntoDescriptor);
     523        @getByIdDirectPrivate(controller, "queue").size -= bytesToCopy;
     524        @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length === 0 || @getByIdDirectPrivate(controller, "pendingPullIntos")[0] === pullIntoDescriptor);
    520525        @readableByteStreamControllerInvalidateBYOBRequest(controller);
    521526        pullIntoDescriptor.bytesFilled += bytesToCopy;
    … …  
    524529
    525530    if (!ready) {
    526         @assert(controller.@queue.size === 0);
     531        @assert(@getByIdDirectPrivate(controller, "queue").size === 0);
    527532        @assert(pullIntoDescriptor.bytesFilled > 0);
    528533        @assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);
    … …  
    537542    "use strict";
    538543
    539     let descriptor = controller.@pendingPullIntos.@shift();
     544    let descriptor = @getByIdDirectPrivate(controller, "pendingPullIntos").@shift();
    540545    @readableByteStreamControllerInvalidateBYOBRequest(controller);
    541546    return descriptor;
    … …  
    546551    "use strict";
    547552
    548     if (controller.@byobRequest === @undefined)
     553    if (@getByIdDirectPrivate(controller, "byobRequest") === @undefined)
    549554        return;
    550     controller.@byobRequest.@associatedReadableByteStreamController = @undefined;
    551     controller.@byobRequest.@view = @undefined;
    552     controller.@byobRequest = @undefined;
     555    const byobRequest = @getByIdDirectPrivate(controller, "byobRequest");
     556    @putByIdDirectPrivate(byobRequest, "associatedReadableByteStreamController", @undefined);
     557    @putByIdDirectPrivate(byobRequest, "view", @undefined);
     558    @putByIdDirectPrivate(controller, "byobRequest", @undefined);
    553559}
    554560
    … …  
    558564    "use strict";
    559565
    560     @assert(stream.@state !== @streamErrored);
     566    @assert(@getByIdDirectPrivate(stream, "state") !== @streamErrored);
    561567    let done = false;
    562     if (stream.@state === @streamClosed) {
     568    if (@getByIdDirectPrivate(stream, "state") === @streamClosed) {
    563569        @assert(!pullIntoDescriptor.bytesFilled);
    564570        done = true;
    … …  
    588594    "use strict";
    589595
    590     stream.@reader.@readIntoRequests.@shift().@resolve.@call(@undefined, {value: chunk, done: done});
     596    @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readIntoRequests").@shift().@resolve.@call(@undefined, {value: chunk, done: done});
    591597}
    592598
    … …  
    595601    "use strict";
    596602
    597     const stream = reader.@ownerReadableStream;
     603    const stream = @getByIdDirectPrivate(reader, "ownerReadableStream");
    598604    @assert(!!stream);
    599605
    600     stream.@disturbed = true;
    601     if (stream.@state === @streamErrored)
    602         return @Promise.@reject(stream.@storedError);
    603 
    604     return @readableByteStreamControllerPullInto(stream.@readableStreamController, view);
     606    @putByIdDirectPrivate(stream, "disturbed", true);
     607    if (@getByIdDirectPrivate(stream, "state") === @streamErrored)
     608        return @Promise.@reject(@getByIdDirectPrivate(stream, "storedError"));
     609
     610    return @readableByteStreamControllerPullInto(@getByIdDirectPrivate(stream, "readableStreamController"), view);
    605611}
    606612
    … …  
    609615    "use strict";
    610616
    611     const stream = controller.@controlledReadableStream;
     617    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
    612618    let elementSize = 1;
    613619    // Spec describes that in the case where view is a TypedArray, elementSize
    … …  
    642648    };
    643649
    644     if (controller.@pendingPullIntos.length) {
     650    if (@getByIdDirectPrivate(controller, "pendingPullIntos").length) {
    645651        pullIntoDescriptor.buffer = @transferBufferToCurrentRealm(pullIntoDescriptor.buffer);
    646         controller.@pendingPullIntos.@push(pullIntoDescriptor);
     652        @getByIdDirectPrivate(controller, "pendingPullIntos").@push(pullIntoDescriptor);
    647653        return @readableStreamAddReadIntoRequest(stream);
    648654    }
    649655
    650     if (stream.@state === @streamClosed) {
     656    if (@getByIdDirectPrivate(stream, "state") === @streamClosed) {
    651657        const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
    652658        return @Promise.@resolve({ value: emptyView, done: true });
    653659    }
    654660
    655     if (controller.@queue.size > 0) {
     661    if (@getByIdDirectPrivate(controller, "queue").size > 0) {
    656662        if (@readableByteStreamControllerFillDescriptorFromQueue(controller, pullIntoDescriptor)) {
    657663            const filledView = @readableByteStreamControllerConvertDescriptor(pullIntoDescriptor);
    … …  
    659665            return @Promise.@resolve({ value: filledView, done: false });
    660666        }
    661         if (controller.@closeRequested) {
     667        if (@getByIdDirectPrivate(controller, "closeRequested")) {
    662668            const e = new @TypeError("Closing stream has been requested");
    663669            @readableByteStreamControllerError(controller, e);
    … …  
    667673
    668674    pullIntoDescriptor.buffer = @transferBufferToCurrentRealm(pullIntoDescriptor.buffer);
    669     controller.@pendingPullIntos.@push(pullIntoDescriptor);
     675    @getByIdDirectPrivate(controller, "pendingPullIntos").@push(pullIntoDescriptor);
    670676    const promise = @readableStreamAddReadIntoRequest(stream);
    671677    @readableByteStreamControllerCallPullIfNeeded(controller);
    … …  
    677683    "use strict";
    678684
    679     @assert(@isReadableStreamBYOBReader(stream.@reader));
    680     @assert(stream.@state === @streamReadable || stream.@state === @streamClosed);
     685    @assert(@isReadableStreamBYOBReader(@getByIdDirectPrivate(stream, "reader")));
     686    @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable || @getByIdDirectPrivate(stream, "state") === @streamClosed);
    681687
    682688    const readRequest = @newPromiseCapability(@Promise);
    683     stream.@reader.@readIntoRequests.@push(readRequest);
     689    @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readIntoRequests").@push(readRequest);
    684690
    685691    return readRequest.@promise;

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

    r225784 r230637  
    4242        @throwTypeError("ReadableStream constructor takes an object as second argument, if any");
    4343
    44     this.@state = @streamReadable;
    45     this.@reader = @undefined;
    46     this.@storedError = @undefined;
    47     this.@disturbed = false;
     44    @putByIdDirectPrivate(this, "state", @streamReadable);
     45    @putByIdDirectPrivate(this, "reader", @undefined);
     46    @putByIdDirectPrivate(this, "storedError", @undefined);
     47    @putByIdDirectPrivate(this, "disturbed", false);
    4848    // Initialized with null value to enable distinction with undefined case.
    49     this.@readableStreamController = null;
     49    @putByIdDirectPrivate(this, "readableStreamController", null);
    5050
    5151    const type = underlyingSource.type;
    52     const typeString = @String(type);
     52    const typeString = @toString(type);
    5353
    5454    if (typeString === "bytes") {
    … …  
    6262
    6363        let readableByteStreamControllerConstructor = @ReadableByteStreamController;
    64         this.@readableStreamController = new @ReadableByteStreamController(this, underlyingSource, strategy.highWaterMark);
     64        @putByIdDirectPrivate(this, "readableStreamController", new @ReadableByteStreamController(this, underlyingSource, strategy.highWaterMark));
    6565    } else if (type === @undefined) {
    6666        if (strategy.highWaterMark === @undefined)
    6767            strategy.highWaterMark = 1;
    68         this.@readableStreamController = new @ReadableStreamDefaultController(this, underlyingSource, strategy.size, strategy.highWaterMark);
     68        @putByIdDirectPrivate(this, "readableStreamController", new @ReadableStreamDefaultController(this, underlyingSource, strategy.size, strategy.highWaterMark));
    6969    } else
    7070        @throwRangeError("Invalid type for underlying source");
    … …  
    114114    const promise = this.pipeTo(writable, options);
    115115    if (@isPromise(promise))
    116         promise.@promiseIsHandled = true;
     116        @putByIdDirectPrivate(promise, "promiseIsHandled", true);
    117117    return readable;
    118118}

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

    r221417 r230637  
    3232        return @Promise.@reject(@makeThisTypeError("ReadableStreamBYOBReader", "cancel"));
    3333
    34     if (!this.@ownerReadableStream)
     34    if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
    3535        return @Promise.@reject(new @TypeError("cancel() called on a reader owned by no readable stream"));
    3636
    … …  
    4545        return @Promise.@reject(@makeThisTypeError("ReadableStreamBYOBReader", "read"));
    4646
    47     if (!this.@ownerReadableStream)
     47    if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
    4848        return @Promise.@reject(new @TypeError("read() called on a reader owned by no readable stream"));
    4949
    … …  
    6767        throw @makeThisTypeError("ReadableStreamBYOBReader", "releaseLock");
    6868
    69     if (!this.@ownerReadableStream)
     69    if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
    7070        return;
    7171
    72     if (this.@readIntoRequests.length)
     72    if (@getByIdDirectPrivate(this, "readIntoRequests").length)
    7373        @throwTypeError("There are still pending read requests, cannot release the lock");
    7474
    … …  
    8484        return @Promise.@reject(@makeGetterTypeError("ReadableStreamBYOBReader", "closed"));
    8585
    86     return this.@closedPromiseCapability.@promise;
     86    return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
    8787}

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

    r221417 r230637  
    3333        throw @makeThisTypeError("ReadableStreamBYOBRequest", "respond");
    3434
    35     if (this.@associatedReadableByteStreamController === @undefined)
     35    if (@getByIdDirectPrivate(this, "associatedReadableByteStreamController") === @undefined)
    3636        @throwTypeError("ReadableStreamBYOBRequest.associatedReadableByteStreamController is undefined");
    3737
    38     return @readableByteStreamControllerRespond(this.@associatedReadableByteStreamController, bytesWritten);
     38    return @readableByteStreamControllerRespond(@getByIdDirectPrivate(this, "associatedReadableByteStreamController"), bytesWritten);
    3939}
    4040
    … …  
    4646        throw @makeThisTypeError("ReadableStreamBYOBRequest", "respond");
    4747
    48     if (this.@associatedReadableByteStreamController === @undefined)
     48    if (@getByIdDirectPrivate(this, "associatedReadableByteStreamController") === @undefined)
    4949        @throwTypeError("ReadableStreamBYOBRequest.associatedReadableByteStreamController is undefined");
    5050
    … …  
    5555        @throwTypeError("Provided view is not an ArrayBufferView");
    5656
    57     return @readableByteStreamControllerRespondWithNewView(this.@associatedReadableByteStreamController, view);
     57    return @readableByteStreamControllerRespondWithNewView(@getByIdDirectPrivate(this, "associatedReadableByteStreamController"), view);
    5858}
    5959
    … …  
    6666        throw @makeGetterTypeError("ReadableStreamBYOBRequest", "view");
    6767
    68     return this.@view;
     68    return @getByIdDirectPrivate(this, "view");
    6969}

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

    r223044 r230637  
    4646        throw @makeThisTypeError("ReadableStreamDefaultController", "error");
    4747
    48     if (this.@controlledReadableStream.@state !== @streamReadable)
     48    if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
    4949        @throwTypeError("ReadableStream is not readable");
    5050

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

    r221417 r230637  
    3333        return @Promise.@reject(@makeThisTypeError("ReadableStreamDefaultReader", "cancel"));
    3434
    35     if (!this.@ownerReadableStream)
     35    if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
    3636        return @Promise.@reject(new @TypeError("cancel() called on a reader owned by no readable stream"));
    3737
    … …  
    4545    if (!@isReadableStreamDefaultReader(this))
    4646        return @Promise.@reject(@makeThisTypeError("ReadableStreamDefaultReader", "read"));
    47     if (!this.@ownerReadableStream)
     47    if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
    4848        return @Promise.@reject(new @TypeError("read() called on a reader owned by no readable stream"));
    4949
    … …  
    5858        throw @makeThisTypeError("ReadableStreamDefaultReader", "releaseLock");
    5959
    60     if (!this.@ownerReadableStream)
     60    if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
    6161        return;
    6262
    63     if (this.@readRequests.length)
     63    if (@getByIdDirectPrivate(this, "readRequests").length)
    6464        @throwTypeError("There are still pending read requests, cannot release the lock");
    6565
    … …  
    7575        return @Promise.@reject(@makeGetterTypeError("ReadableStreamDefaultReader", "closed"));
    7676
    77     return this.@closedPromiseCapability.@promise;
     77    return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
    7878}

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

    r223044 r230637  
    3838
    3939    @readableStreamReaderGenericInitialize(this, stream);
    40     this.@readRequests = [];
     40    @putByIdDirectPrivate(this, "readRequests", []);
    4141
    4242    return this;
    … …  
    4747    "use strict";
    4848
    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() };
     49    @putByIdDirectPrivate(reader, "ownerReadableStream", stream);
     50    @putByIdDirectPrivate(stream, "reader", reader);
     51    if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
     52        @putByIdDirectPrivate(reader, "closedPromiseCapability", @newPromiseCapability(@Promise));
     53    else if (@getByIdDirectPrivate(stream, "state") === @streamClosed)
     54        @putByIdDirectPrivate(reader, "closedPromiseCapability", { @promise: @Promise.@resolve() });
    5555    else {
    56         @assert(stream.@state === @streamErrored);
    57         reader.@closedPromiseCapability = { @promise: @newHandledRejectedPromise(stream.@storedError) };
     56        @assert(@getByIdDirectPrivate(stream, "state") === @streamErrored);
     57        @putByIdDirectPrivate(reader, "closedPromiseCapability", { @promise: @newHandledRejectedPromise(@getByIdDirectPrivate(stream, "storedError")) });
    5858    }
    5959}
    … …  
    6767
    6868    // readableStreamController is initialized with null value.
    69     if (stream.@readableStreamController !== null)
     69    if (@getByIdDirectPrivate(stream, "readableStreamController") !== null)
    7070        @throwTypeError("ReadableStream already has a controller");
    7171
    72     this.@controlledReadableStream = stream;
    73     this.@underlyingSource = underlyingSource;
    74     this.@queue = @newQueue();
    75     this.@started = false;
    76     this.@closeRequested = false;
    77     this.@pullAgain = false;
    78     this.@pulling = false;
    79     this.@strategy = @validateAndNormalizeQueuingStrategy(size, highWaterMark);
     72    @putByIdDirectPrivate(this, "controlledReadableStream", stream);
     73    @putByIdDirectPrivate(this, "underlyingSource", underlyingSource);
     74    @putByIdDirectPrivate(this, "queue", @newQueue());
     75    @putByIdDirectPrivate(this, "started", false);
     76    @putByIdDirectPrivate(this, "closeRequested", false);
     77    @putByIdDirectPrivate(this, "pullAgain", false);
     78    @putByIdDirectPrivate(this, "pulling", false);
     79    @putByIdDirectPrivate(this, "strategy", @validateAndNormalizeQueuingStrategy(size, highWaterMark));
    8080
    8181    const controller = this;
    8282    @promiseInvokeOrNoopNoCatch(underlyingSource, "start", [this]).@then(() => {
    83         controller.@started = true;
    84         @assert(!controller.@pulling);
    85         @assert(!controller.@pullAgain);
     83        @putByIdDirectPrivate(controller, "started", true);
     84        @assert(!@getByIdDirectPrivate(controller, "pulling"));
     85        @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
    8686        @readableStreamDefaultControllerCallPullIfNeeded(controller);
    8787    }, (error) => {
    88         if (stream.@state === @streamReadable)
     88        if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
    8989            @readableStreamDefaultControllerError(controller, error);
    9090    });
    9191
    92     this.@cancel = @readableStreamDefaultControllerCancel;
    93 
    94     this.@pull = @readableStreamDefaultControllerPull;
     92    @putByIdDirectPrivate(this, "cancel", @readableStreamDefaultControllerCancel);
     93
     94    @putByIdDirectPrivate(this, "pull", @readableStreamDefaultControllerPull);
    9595
    9696    return this;
    … …  
    101101    "use strict";
    102102
    103     const stream = controller.@controlledReadableStream;
    104     @assert(stream.@state === @streamReadable);
    105     controller.@queue = @newQueue();
     103    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
     104    @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
     105    @putByIdDirectPrivate(controller, "queue", @newQueue());
    106106    @readableStreamError(stream, error);
    107107}
    … …  
    114114    const reader = new @ReadableStreamDefaultReader(stream);
    115115
    116     reader.@closedPromiseCapability.@promise.@then(() => { }, (e) => { sink.error(e); });
     116    @getByIdDirectPrivate(reader, "closedPromiseCapability").@promise.@then(() => { }, (e) => { sink.error(e); });
    117117
    118118    function doPipe() {
    … …  
    164164    });
    165165
    166     reader.@closedPromiseCapability.@promise.@then(@undefined, function(e) {
     166    @getByIdDirectPrivate(reader, "closedPromiseCapability").@promise.@then(@undefined, function(e) {
    167167        if (teeState.closedOrErrored)
    168168            return;
    … …  
    259259    // However, since it is a private slot, it cannot be checked using hasOwnProperty().
    260260    // Therefore, readableStreamController is initialized with null value.
    261     return @isObject(stream) && stream.@readableStreamController !== @undefined;
     261    return @isObject(stream) && @getByIdDirectPrivate(stream, "readableStreamController") !== @undefined;
    262262}
    263263
    … …  
    269269    // However, since it is a private slot, it cannot be checked using hasOwnProperty().
    270270    // Since readRequests is initialized with an empty array, the following test is ok.
    271     return @isObject(reader) && !!reader.@readRequests;
     271    return @isObject(reader) && !!@getByIdDirectPrivate(reader, "readRequests");
    272272}
    273273
    … …  
    280280    // underlyingSource is obtained in ReadableStream constructor: if undefined, it is set
    281281    // to an empty object. Therefore, following test is ok.
    282     return @isObject(controller) && !!controller.@underlyingSource;
     282    return @isObject(controller) && !!@getByIdDirectPrivate(controller, "underlyingSource");
    283283}
    284284
    … …  
    288288
    289289    @assert(@isReadableStream(stream));
    290     @assert(stream.@state === @streamReadable);
    291     stream.@state = @streamErrored;
    292     stream.@storedError = error;
    293 
    294     if (!stream.@reader)
    295         return;
    296 
    297     const reader = stream.@reader;
     290    @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
     291    @putByIdDirectPrivate(stream, "state", @streamErrored);
     292    @putByIdDirectPrivate(stream, "storedError", error);
     293
     294    if (!@getByIdDirectPrivate(stream, "reader"))
     295        return;
     296
     297    const reader = @getByIdDirectPrivate(stream, "reader");
    298298
    299299    if (@isReadableStreamDefaultReader(reader)) {
    300         const requests = reader.@readRequests;
     300        const requests = @getByIdDirectPrivate(reader, "readRequests");
    301301        for (let index = 0, length = requests.length; index < length; ++index)
    302302            requests[index].@reject.@call(@undefined, error);
    303         reader.@readRequests = [];
     303        @putByIdDirectPrivate(reader, "readRequests", []);
    304304    } else {
    305305        @assert(@isReadableStreamBYOBReader(reader));
    306         const requests = reader.@readIntoRequests;
     306        const requests = @getByIdDirectPrivate(reader, "readIntoRequests");
    307307        for (let index = 0, length = requests.length; index < length; ++index)
    308308            requests[index].@reject.@call(@undefined, error);
    309         reader.@readIntoRequests = [];
    310     }
    311 
    312     reader.@closedPromiseCapability.@reject.@call(@undefined, error);
    313     reader.@closedPromiseCapability.@promise.@promiseIsHandled = true;
     309        @putByIdDirectPrivate(reader, "readIntoRequests", []);
     310    }
     311
     312    @getByIdDirectPrivate(reader, "closedPromiseCapability").@reject.@call(@undefined, error);
     313    @putByIdDirectPrivate(@getByIdDirectPrivate(reader, "closedPromiseCapability").@promise, "promiseIsHandled", true);
    314314}
    315315
    … …  
    318318    "use strict";
    319319
    320     const stream = controller.@controlledReadableStream;
     320    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
    321321
    322322    if (!@readableStreamDefaultControllerCanCloseOrEnqueue(controller))
    323323        return;
    324     if (!controller.@started)
    325         return;
    326     if ((!@isReadableStreamLocked(stream) || !stream.@reader.@readRequests.length) && @readableStreamDefaultControllerGetDesiredSize(controller) <= 0)
    327         return;
    328 
    329     if (controller.@pulling) {
    330         controller.@pullAgain = true;
    331         return;
    332     }
    333 
    334     @assert(!controller.@pullAgain);
    335     controller.@pulling = true;
    336 
    337     @promiseInvokeOrNoop(controller.@underlyingSource, "pull", [controller]).@then(function() {
    338         controller.@pulling = false;
    339         if (controller.@pullAgain) {
    340             controller.@pullAgain = false;
     324    if (!@getByIdDirectPrivate(controller, "started"))
     325        return;
     326    if ((!@isReadableStreamLocked(stream) || !@getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length) && @readableStreamDefaultControllerGetDesiredSize(controller) <= 0)
     327        return;
     328
     329    if (@getByIdDirectPrivate(controller, "pulling")) {
     330        @putByIdDirectPrivate(controller, "pullAgain", true);
     331        return;
     332    }
     333
     334    @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
     335    @putByIdDirectPrivate(controller, "pulling", true);
     336
     337    @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingSource"), "pull", [controller]).@then(function() {
     338        @putByIdDirectPrivate(controller, "pulling", false);
     339        if (@getByIdDirectPrivate(controller, "pullAgain")) {
     340            @putByIdDirectPrivate(controller, "pullAgain", false);
    341341            @readableStreamDefaultControllerCallPullIfNeeded(controller);
    342342        }
    343343    }, function(error) {
    344         if (stream.@state === @streamReadable)
     344        if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
    345345            @readableStreamDefaultControllerError(controller, error);
    346346    });
    … …  
    352352
    353353    @assert(@isReadableStream(stream));
    354     return !!stream.@reader;
     354    return !!@getByIdDirectPrivate(stream, "reader");
    355355}
    356356
    … …  
    359359   "use strict";
    360360
    361    const stream = controller.@controlledReadableStream;
    362 
    363    if (stream.@state === @streamErrored)
    364        return null;
    365    if (stream.@state === @streamClosed)
    366        return 0;
    367 
    368    return controller.@strategy.highWaterMark - controller.@queue.size;
     361    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
     362    const state = @getByIdDirectPrivate(stream, "state");
     363
     364    if (state === @streamErrored)
     365        return null;
     366    if (state === @streamClosed)
     367        return 0;
     368
     369    return @getByIdDirectPrivate(controller, "strategy").highWaterMark - @getByIdDirectPrivate(controller, "queue").size;
    369370}
    370371
    … …  
    374375    "use strict";
    375376
    376     const stream = reader.@ownerReadableStream;
     377    const stream = @getByIdDirectPrivate(reader, "ownerReadableStream");
    377378    @assert(!!stream);
    378379    return @readableStreamCancel(stream, reason);
    … …  
    383384    "use strict";
    384385
    385     stream.@disturbed = true;
    386     if (stream.@state === @streamClosed)
     386    @putByIdDirectPrivate(stream, "disturbed", true);
     387    const state = @getByIdDirectPrivate(stream, "state");
     388    if (state === @streamClosed)
    387389        return @Promise.@resolve();
    388     if (stream.@state === @streamErrored)
    389         return @Promise.@reject(stream.@storedError);
     390    if (state === @streamErrored)
     391        return @Promise.@reject(@getByIdDirectPrivate(stream, "storedError"));
    390392    @readableStreamClose(stream);
    391     return stream.@readableStreamController.@cancel(stream.@readableStreamController, reason).@then(function() {  });
     393    return @getByIdDirectPrivate(stream, "readableStreamController").@cancel(@getByIdDirectPrivate(stream, "readableStreamController"), reason).@then(function() {  });
    392394}
    393395
    … …  
    396398    "use strict";
    397399
    398     controller.@queue = @newQueue();
    399     return @promiseInvokeOrNoop(controller.@underlyingSource, "cancel", [reason]);
     400    @putByIdDirectPrivate(controller, "queue", @newQueue());
     401    return @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingSource"), "cancel", [reason]);
    400402}
    401403
    … …  
    404406    "use strict";
    405407
    406     const stream = controller.@controlledReadableStream;
    407     if (controller.@queue.content.length) {
    408         const chunk = @dequeueValue(controller.@queue);
    409         if (controller.@closeRequested && controller.@queue.content.length === 0)
     408    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
     409    if (@getByIdDirectPrivate(controller, "queue").content.length) {
     410        const chunk = @dequeueValue(@getByIdDirectPrivate(controller, "queue"));
     411        if (@getByIdDirectPrivate(controller, "closeRequested") && @getByIdDirectPrivate(controller, "queue").content.length === 0)
    410412            @readableStreamClose(stream);
    411413        else
    … …  
    423425
    424426    @assert(@readableStreamDefaultControllerCanCloseOrEnqueue(controller));
    425     controller.@closeRequested = true;
    426     if (controller.@queue.content.length === 0)
    427         @readableStreamClose(controller.@controlledReadableStream);
     427    @putByIdDirectPrivate(controller, "closeRequested", true);
     428    if (@getByIdDirectPrivate(controller, "queue").content.length === 0)
     429        @readableStreamClose(@getByIdDirectPrivate(controller, "controlledReadableStream"));
    428430}
    429431
    … …  
    432434    "use strict";
    433435
    434     @assert(stream.@state === @streamReadable);
    435     stream.@state = @streamClosed;
    436     const reader = stream.@reader;
     436    @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
     437    @putByIdDirectPrivate(stream, "state", @streamClosed);
     438    const reader = @getByIdDirectPrivate(stream, "reader");
    437439
    438440    if (!reader)
    … …  
    440442
    441443    if (@isReadableStreamDefaultReader(reader)) {
    442         const requests = reader.@readRequests;
     444        const requests = @getByIdDirectPrivate(reader, "readRequests");
    443445        for (let index = 0, length = requests.length; index < length; ++index)
    444446            requests[index].@resolve.@call(@undefined, {value:@undefined, done: true});
    445         reader.@readRequests = [];
    446     }
    447 
    448     reader.@closedPromiseCapability.@resolve.@call();
     447        @putByIdDirectPrivate(reader, "readRequests", []);
     448    }
     449
     450    @getByIdDirectPrivate(reader, "closedPromiseCapability").@resolve.@call();
    449451}
    450452
    … …  
    453455    "use strict";
    454456
    455     stream.@reader.@readRequests.@shift().@resolve.@call(@undefined, {value: chunk, done: done});
     457    @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").@shift().@resolve.@call(@undefined, {value: chunk, done: done});
    456458}
    457459
    … …  
    460462    "use strict";
    461463
    462     const stream = controller.@controlledReadableStream;
     464    const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
    463465    @assert(@readableStreamDefaultControllerCanCloseOrEnqueue(controller));
    464466
    465     if (@isReadableStreamLocked(stream) && stream.@reader.@readRequests.length) {
     467    if (@isReadableStreamLocked(stream) && @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length) {
    466468        @readableStreamFulfillReadRequest(stream, chunk, false);
    467469        @readableStreamDefaultControllerCallPullIfNeeded(controller);
    … …  
    471473    try {
    472474        let chunkSize = 1;
    473         if (controller.@strategy.size !== @undefined)
    474             chunkSize = controller.@strategy.size(chunk);
    475         @enqueueValueWithSize(controller.@queue, chunk, chunkSize);
     475        if (@getByIdDirectPrivate(controller, "strategy").size !== @undefined)
     476            chunkSize = @getByIdDirectPrivate(controller, "strategy").size(chunk);
     477        @enqueueValueWithSize(@getByIdDirectPrivate(controller, "queue"), chunk, chunkSize);
    476478    }
    477479    catch(error) {
    478         if (stream.@state === @streamReadable)
     480        if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
    479481            @readableStreamDefaultControllerError(controller, error);
    480482        throw error;
    … …  
    487489    "use strict";
    488490
    489     const stream = reader.@ownerReadableStream;
     491    const stream = @getByIdDirectPrivate(reader, "ownerReadableStream");
    490492    @assert(!!stream);
    491 
    492     stream.@disturbed = true;
    493     if (stream.@state === @streamClosed)
     493    const state = @getByIdDirectPrivate(stream, "state");
     494
     495    @putByIdDirectPrivate(stream, "disturbed", true);
     496    if (state === @streamClosed)
    494497        return @Promise.@resolve({value: @undefined, done: true});
    495     if (stream.@state === @streamErrored)
    496         return @Promise.@reject(stream.@storedError);
    497     @assert(stream.@state === @streamReadable);
    498 
    499     return stream.@readableStreamController.@pull(stream.@readableStreamController);
     498    if (state === @streamErrored)
     499        return @Promise.@reject(@getByIdDirectPrivate(stream, "storedError"));
     500    @assert(state === @streamReadable);
     501
     502    return @getByIdDirectPrivate(stream, "readableStreamController").@pull(@getByIdDirectPrivate(stream, "readableStreamController"));
    500503}
    501504
    … …  
    504507    "use strict";
    505508
    506     @assert(@isReadableStreamDefaultReader(stream.@reader));
    507     @assert(stream.@state == @streamReadable);
     509    @assert(@isReadableStreamDefaultReader(@getByIdDirectPrivate(stream, "reader")));
     510    @assert(@getByIdDirectPrivate(stream, "state") == @streamReadable);
    508511
    509512    const readRequest = @newPromiseCapability(@Promise);
    510     stream.@reader.@readRequests.@push(readRequest);
     513    @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").@push(readRequest);
    511514
    512515    return readRequest.@promise;
    … …  
    518521
    519522    @assert(@isReadableStream(stream));
    520     return stream.@disturbed;
     523    return @getByIdDirectPrivate(stream, "disturbed");
    521524}
    522525
    … …  
    525528    "use strict";
    526529
    527     @assert(!!reader.@ownerReadableStream);
    528     @assert(reader.@ownerReadableStream.@reader === reader);
    529 
    530     if (reader.@ownerReadableStream.@state === @streamReadable)
    531         reader.@closedPromiseCapability.@reject.@call(@undefined, new @TypeError("releasing lock of reader whose stream is still in readable state"));
     530    @assert(!!@getByIdDirectPrivate(reader, "ownerReadableStream"));
     531    @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(reader, "ownerReadableStream"), "reader") === reader);
     532
     533    if (@getByIdDirectPrivate(@getByIdDirectPrivate(reader, "ownerReadableStream"), "state") === @streamReadable)
     534        @getByIdDirectPrivate(reader, "closedPromiseCapability").@reject.@call(@undefined, new @TypeError("releasing lock of reader whose stream is still in readable state"));
    532535    else
    533         reader.@closedPromiseCapability = { @promise: @newHandledRejectedPromise(new @TypeError("reader released lock")) };
    534 
    535     reader.@closedPromiseCapability.@promise.@promiseIsHandled = true;
    536     reader.@ownerReadableStream.@reader = @undefined;
    537     reader.@ownerReadableStream = @undefined;
     536        @putByIdDirectPrivate(reader, "closedPromiseCapability", { @promise: @newHandledRejectedPromise(new @TypeError("reader released lock")) });
     537
     538    @putByIdDirectPrivate(@getByIdDirectPrivate(reader, "closedPromiseCapability").@promise, "promiseIsHandled", true);
     539    @putByIdDirectPrivate(@getByIdDirectPrivate(reader, "ownerReadableStream"), "reader", @undefined);
     540    @putByIdDirectPrivate(reader, "ownerReadableStream", @undefined);
    538541}
    539542
    … …  
    542545    "use strict";
    543546
    544     return !controller.@closeRequested && controller.@controlledReadableStream.@state === @streamReadable;
    545 }
     547    return !@getByIdDirectPrivate(controller, "closeRequested") && @getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable;
     548}

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

    r223279 r230637  
    8282        @throwTypeError("size parameter must be a function");
    8383
    84     const normalizedStrategy = { };
    85 
    86     normalizedStrategy.size = size;
    87     normalizedStrategy.highWaterMark = @toNumber(highWaterMark);
     84    const normalizedStrategy = {
     85        size: size,
     86        highWaterMark: @toNumber(highWaterMark)
     87    };
    8888
    8989    if (@isNaN(normalizedStrategy.highWaterMark) || normalizedStrategy.highWaterMark < 0)

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

    r221417 r230637  
    4242        @throwTypeError("WritableStream constructor takes an object as second argument, if any");
    4343
    44     this.@underlyingSink = underlyingSink;
    45     this.@closedPromiseCapability = @newPromiseCapability(@Promise);
    46     this.@readyPromiseCapability = { @promise: @Promise.@resolve() };
    47     this.@queue = @newQueue();
    48     this.@state = @streamWritable;
    49     this.@started = false;
    50     this.@writing = false;
     44    @putByIdDirectPrivate(this, "underlyingSink", underlyingSink);
     45    @putByIdDirectPrivate(this, "closedPromiseCapability", @newPromiseCapability(@Promise));
     46    @putByIdDirectPrivate(this, "readyPromiseCapability", { @promise: @Promise.@resolve() });
     47    @putByIdDirectPrivate(this, "queue", @newQueue());
     48    @putByIdDirectPrivate(this, "state", @streamWritable);
     49    @putByIdDirectPrivate(this, "started", false);
     50    @putByIdDirectPrivate(this, "writing", false);
    5151
    52     this.@strategy = @validateAndNormalizeQueuingStrategy(strategy.size, strategy.highWaterMark);
     52    @putByIdDirectPrivate(this, "strategy", @validateAndNormalizeQueuingStrategy(strategy.size, strategy.highWaterMark));
    5353
    5454    @syncWritableStreamStateWithQueue(this);
    … …  
    5757        @errorWritableStream(this, e);
    5858    };
    59     this.@startedPromise = @promiseInvokeOrNoopNoCatch(underlyingSink, "start", [errorFunction]);
    60     this.@startedPromise.@then(() => {
    61         this.@started = true;
    62         this.@startedPromise = @undefined;
     59    @putByIdDirectPrivate(this, "startedPromise", @promiseInvokeOrNoopNoCatch(underlyingSink, "start", [errorFunction]));
     60    @getByIdDirectPrivate(this, "startedPromise").@then(() => {
     61        @putByIdDirectPrivate(this, "started", true);
     62        @putByIdDirectPrivate(this, "startedPromise", @undefined);
    6363    }, errorFunction);
    6464
    … …  
    7373        return @Promise.@reject(new @TypeError("The WritableStream.abort method can only be used on instances of WritableStream"));
    7474
    75     if (this.@state === @streamClosed)
     75    const state = @getByIdDirectPrivate(this, "state");
     76    if (state === @streamClosed)
    7677        return @Promise.@resolve();
    7778
    78     if (this.@state === @streamErrored)
    79         return @Promise.@reject(this.@storedError);
     79    if (state === @streamErrored)
     80        return @Promise.@reject(@getByIdDirectPrivate(this, "storedError"));
    8081
    8182    @errorWritableStream(this, reason);
    8283
    83     return @promiseInvokeOrFallbackOrNoop(this.@underlyingSink, "abort", [reason], "close", []).@then(function() { });
     84    return @promiseInvokeOrFallbackOrNoop(@getByIdDirectPrivate(this, "underlyingSink"), "abort", [reason], "close", []).@then(function() { });
    8485}
    8586
    … …  
    9192        return @Promise.@reject(new @TypeError("The WritableStream.close method can only be used on instances of WritableStream"));
    9293
    93     if (this.@state === @streamClosed || this.@state === @streamClosing)
     94    const state = @getByIdDirectPrivate(this, "state");
     95    if (state === @streamClosed || state === @streamClosing)
    9496        return @Promise.@reject(new @TypeError("Cannot close a WritableString that is closed or closing"));
    9597
    96     if (this.@state === @streamErrored)
    97         return @Promise.@reject(this.@storedError);
     98    if (state === @streamErrored)
     99        return @Promise.@reject(@getByIdDirectPrivate(this, "storedError"));
    98100
    99     if (this.@state === @streamWaiting)
    100         this.@readyPromiseCapability.@resolve.@call();
     101    if (state === @streamWaiting)
     102        @getByIdDirectPrivate(this, "readyPromiseCapability").@resolve.@call();
    101103
    102     this.@state = @streamClosing;
    103     @enqueueValueWithSize(this.@queue, "close", 0);
     104    @putByIdDirectPrivate(this, "state", @streamClosing);
     105    @enqueueValueWithSize(@getByIdDirectPrivate(this, "queue"), "close", 0);
    104106    @callOrScheduleWritableStreamAdvanceQueue(this);
    105107
    106     return this.@closedPromiseCapability.@promise;
     108    return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
    107109}
    108110
    … …  
    114116        return @Promise.@reject(new @TypeError("The WritableStream.write method can only be used on instances of WritableStream"));
    115117
    116     if (this.@state === @streamClosed || this.@state === @streamClosing)
     118    const state = @getByIdDirectPrivate(this, "state");
     119    if (state === @streamClosed || state === @streamClosing)
    117120        return @Promise.@reject(new @TypeError("Cannot write on a WritableString that is closed or closing"));
    118121
    119     if (this.@state === @streamErrored)
     122    if (state === @streamErrored)
    120123        return @Promise.@reject(this.@storedError);
    121124
    122     @assert(this.@state === @streamWritable || this.@state === @streamWaiting);
     125    @assert(state === @streamWritable || state === @streamWaiting);
    123126
    124127    let chunkSize = 1;
    125     if (this.@strategy.size !== @undefined) {
     128    if (@getByIdDirectPrivate(this, "strategy").size !== @undefined) {
    126129        try {
    127             chunkSize = this.@strategy.size.@call(@undefined, chunk);
     130            chunkSize = @getByIdDirectPrivate(this, "strategy").size.@call(@undefined, chunk);
    128131        } catch(e) {
    129132            @errorWritableStream(this, e);
    … …  
    134137    const promiseCapability = @newPromiseCapability(@Promise);
    135138    try {
    136         @enqueueValueWithSize(this.@queue, { promiseCapability: promiseCapability, chunk: chunk }, chunkSize);
     139        @enqueueValueWithSize(@getByIdDirectPrivate(this, "queue"), { promiseCapability: promiseCapability, chunk: chunk }, chunkSize);
    137140    } catch (e) {
    138141        @errorWritableStream(this, e);
    … …  
    154157        return @Promise.@reject(new @TypeError("The WritableStream.closed getter can only be used on instances of WritableStream"));
    155158
    156     return this.@closedPromiseCapability.@promise;
     159    return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
    157160}
    158161
    … …  
    165168        return @Promise.@reject(new @TypeError("The WritableStream.ready getter can only be used on instances of WritableStream"));
    166169
    167     return this.@readyPromiseCapability.@promise;
     170    return @getByIdDirectPrivate(this, "readyPromiseCapability").@promise;
    168171}
    169172
    … …  
    176179        @throwTypeError("The WritableStream.state getter can only be used on instances of WritableStream");
    177180
    178     switch(this.@state) {
     181    switch(@getByIdDirectPrivate(this, "state")) {
    179182    case @streamClosed:
    180183        return "closed";

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

    r220279 r230637  
    3232    "use strict";
    3333
    34     return @isObject(stream) && !!stream.@underlyingSink;
     34    return @isObject(stream) && !!@getByIdDirectPrivate(stream, "underlyingSink");
    3535}
    3636
    … …  
    3939    "use strict";
    4040
    41     if (stream.@state === @streamClosing)
     41    const state = @getByIdDirectPrivate(stream, "state");
     42    if (state === @streamClosing)
    4243        return;
    4344
    44     @assert(stream.@state === @streamWritable || stream.@state === @streamWaiting);
     45    @assert(state === @streamWritable || state === @streamWaiting);
    4546
    46     const shouldApplyBackpressure = stream.@queue.size > stream.@strategy.highWaterMark;
    47     if (shouldApplyBackpressure && stream.@state === @streamWritable) {
    48         stream.@state = @streamWaiting;
    49         stream.@readyPromiseCapability = @newPromiseCapability(@Promise);
     47    const shouldApplyBackpressure = @getByIdDirectPrivate(stream, "queue").size > @getByIdDirectPrivate(stream, "strategy").highWaterMark;
     48    if (shouldApplyBackpressure && state === @streamWritable) {
     49        @putByIdDirectPrivate(stream, "state", @streamWaiting);
     50        @putByIdDirectPrivate(stream, "readyPromiseCapability", @newPromiseCapability(@Promise));
    5051    }
    51     if (!shouldApplyBackpressure && stream.@state === @streamWaiting) {
    52         stream.@state = @streamWritable;
    53         stream.@readyPromiseCapability.@resolve.@call();
     52    if (!shouldApplyBackpressure && state === @streamWaiting) {
     53        @putByIdDirectPrivate(stream, "state", @streamWritable);
     54        @getByIdDirectPrivate(stream, "readyPromiseCapability").@resolve.@call();
    5455    }
    5556}
    … …  
    5960    "use strict";
    6061
    61     if (stream.@state === @streamClosed || stream.@state === @streamErrored)
     62    const state = @getByIdDirectPrivate(stream, "state");
     63    if (state === @streamClosed || state === @streamErrored)
    6264        return;
    63     while (stream.@queue.content.length > 0) {
    64         const writeRecord = @dequeueValue(stream.@queue);
     65    while (@getByIdDirectPrivate(stream, "queue").content.length > 0) {
     66        const writeRecord = @dequeueValue(@getByIdDirectPrivate(stream, "queue"));
    6567        if (writeRecord !== "close")
    6668            writeRecord.promiseCapability.@reject.@call(@undefined, e);
    6769    }
    68     stream.@storedError = e;
    69     if (stream.@state === @streamWaiting)
    70         stream.@readyPromiseCapability.@resolve.@call();
    71     stream.@closedPromiseCapability.@reject.@call(@undefined, e);
    72     stream.@state = @streamErrored;
     70    @putByIdDirectPrivate(stream, "storedError", e);
     71    if (state === @streamWaiting)
     72        @getByIdDirectPrivate(stream, "readyPromiseCapability").@resolve.@call();
     73    @getByIdDirectPrivate(stream, "closedPromiseCapability").@reject.@call(@undefined, e);
     74    @putByIdDirectPrivate(stream, "state", @streamErrored);
    7375}
    7476
    … …  
    7779    "use strict";
    7880
    79     if (!stream.@started)
    80         stream.@startedPromise.@then(function() { @writableStreamAdvanceQueue(stream); });
     81    if (!@getByIdDirectPrivate(stream, "started"))
     82        @getByIdDirectPrivate(stream, "startedPromise").@then(function() { @writableStreamAdvanceQueue(stream); });
    8183    else
    8284        @writableStreamAdvanceQueue(stream);
    … …  
    8789    "use strict";
    8890
    89     if (stream.@queue.content.length === 0 || stream.@writing)
     91    if (@getByIdDirectPrivate(stream, "queue").content.length === 0 || @getByIdDirectPrivate(stream, "writing"))
    9092        return;
    9193
    92     const writeRecord = @peekQueueValue(stream.@queue);
     94    const writeRecord = @peekQueueValue(@getByIdDirectPrivate(stream, "queue"));
    9395    if (writeRecord === "close") {
    94         @assert(stream.@state === @streamClosing);
    95         @dequeueValue(stream.@queue);
    96         @assert(stream.@queue.content.length === 0);
     96        @assert(@getByIdDirectPrivate(stream, "state") === @streamClosing);
     97        @dequeueValue(@getByIdDirectPrivate(stream, "queue"));
     98        @assert(@getByIdDirectPrivate(stream, "queue").content.length === 0);
    9799        @closeWritableStream(stream);
    98100        return;
    99101    }
    100102
    101     stream.@writing = true;
    102     @promiseInvokeOrNoop(stream.@underlyingSink, "write", [writeRecord.chunk]).@then(
     103    @putByIdDirectPrivate(stream, "writing", true);
     104    @promiseInvokeOrNoop(@getByIdDirectPrivate(stream, "underlyingSink"), "write", [writeRecord.chunk]).@then(
    103105        function() {
    104             if (stream.@state === @streamErrored)
     106            if (@getByIdDirectPrivate(stream, "state") === @streamErrored)
    105107                return;
    106             stream.@writing = false;
     108            @putByIdDirectPrivate(stream, "writing", false);
    107109            writeRecord.promiseCapability.@resolve.@call();
    108             @dequeueValue(stream.@queue);
     110            @dequeueValue(@getByIdDirectPrivate(stream, "queue"));
    109111            @syncWritableStreamStateWithQueue(stream);
    110112            @writableStreamAdvanceQueue(stream);
    … …  
    120122    "use strict";
    121123
    122     @assert(stream.@state === @streamClosing);
    123     @promiseInvokeOrNoop(stream.@underlyingSink, "close").@then(
     124    @assert(@getByIdDirectPrivate(stream, "state") === @streamClosing);
     125    @promiseInvokeOrNoop(@getByIdDirectPrivate(stream, "underlyingSink"), "close").@then(
    124126        function() {
    125             if (stream.@state === @streamErrored)
     127            if (@getByIdDirectPrivate(stream, "state") === @streamErrored)
    126128                return;
    127             @assert(stream.@state === @streamClosing);
    128             stream.@closedPromiseCapability.@resolve.@call();
    129             stream.@state = @streamClosed;
     129            @assert(@getByIdDirectPrivate(stream, "state") === @streamClosing);
     130            @getByIdDirectPrivate(stream, "closedPromiseCapability").@resolve.@call();
     131            @putByIdDirectPrivate(stream, "state", @streamClosed);
    130132        },
    131133        function(r) {

  • trunk/Source/WebCore/bindings/js/JSDOMBindingInternals.js

    r213108 r230637  
    2929{
    3030    "use strict";
    31     this.@backingMap.forEach((value, key, map) => {
     31    @getByIdDirectPrivate(this, "backingMap").forEach((value, key, map) => {
    3232        callback(value, key, this);
    3333    });
Note: See TracChangeset for help on using the changeset viewer.