Diff
Modified: trunk/Source/WebCore/ChangeLog (230636 => 230637)
--- trunk/Source/WebCore/ChangeLog 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/ChangeLog 2018-04-13 17:01:40 UTC (rev 230637)
@@ -1,3 +1,120 @@
+2018-04-13 Yusuke Suzuki <utatane....@gmail.com>
+
+ [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):
+
2018-04-12 Antoine Quint <grao...@apple.com>
[Web Animations] Turn CSS Animations and CSS Transitions as Web Animations on by default
Modified: trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -40,8 +40,8 @@
@throwTypeError("RTCPeerConnection argument must be a valid dictionary");
this.@initializeWith(configuration);
- this.@operations = [];
- this.@localStreams = [];
+ @putByIdDirectPrivate(this, "operations", []);
+ @putByIdDirectPrivate(this, "localStreams", []);
return this;
}
@@ -53,7 +53,7 @@
if (!@isRTCPeerConnection(this))
throw @makeThisTypeError("RTCPeerConnection", "getLocalStreams");
- return this.@localStreams.slice();
+ return @getByIdDirectPrivate(this, "localStreams").slice();
}
function getStreamById(streamIdArg)
@@ -66,9 +66,9 @@
if (arguments.length < 1)
@throwTypeError("Not enough arguments");
- const streamId = @String(streamIdArg);
+ const streamId = @toString(streamIdArg);
- return th...@localstreams.find(stream => stream.id === streamId)
+ return @getByIdDirectPrivate(this, "localStreams").find(stream => stream.id === streamId)
|| this.@getRemoteStreams().find(stream => stream.id === streamId)
|| null;
}
@@ -86,10 +86,10 @@
if (!(stream instanceof @MediaStream))
@throwTypeError("Argument 1 ('stream') to RTCPeerConnection.addStream must be an instance of MediaStream");
- if (th...@localstreams.find(localStream => localStream.id === stream.id))
+ if (@getByIdDirectPrivate(this, "localStreams").find(localStream => localStream.id === stream.id))
return;
- this.@localStreams.@push(stream);
+ @getByIdDirectPrivate(this, "localStreams").@push(stream);
stream.@getTracks().forEach(track => this.@addTrack(track, stream));
}
@@ -106,18 +106,18 @@
if (!(stream instanceof @MediaStream))
@throwTypeError("Argument 1 ('stream') to RTCPeerConnection.removeStream must be an instance of MediaStream");
- const indexOfStreamToRemove = this.@localStreams.findIndex(localStream => localStream.id === stream.id);
+ const indexOfStreamToRemove = @getByIdDirectPrivate(this, "localStreams").findIndex(localStream => localStream.id === stream.id);
if (indexOfStreamToRemove === -1)
return;
const senders = this.@getSenders();
- this.@localStreams[indexOfStreamToRemove].@getTracks().forEach(track => {
+ @getByIdDirectPrivate(this, "localStreams")[indexOfStreamToRemove].@getTracks().forEach(track => {
const senderForTrack = senders.find(sender => sender.track && sender.track.id === track.id);
if (senderForTrack)
this.@removeTrack(senderForTrack);
});
- this.@localStreams.splice(indexOfStreamToRemove, 1);
+ @getByIdDirectPrivate(this, "localStreams").splice(indexOfStreamToRemove, 1);
}
function createOffer()
Modified: trunk/Source/WebCore/Modules/mediastream/RTCPeerConnectionInternals.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/mediastream/RTCPeerConnectionInternals.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/mediastream/RTCPeerConnectionInternals.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -36,7 +36,7 @@
{
"use strict";
- const operations = peerConnection.@operations;
+ const operations = @getByIdDirectPrivate(peerConnection, "operations");
function runNext() {
operations.@shift();
@@ -133,5 +133,5 @@
{
"use strict";
- return @isObject(connection) && !!connection.@operations;
+ return @isObject(connection) && !!@getByIdDirectPrivate(connection, "operations");
}
Modified: trunk/Source/WebCore/Modules/streams/ReadableByteStreamController.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableByteStreamController.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableByteStreamController.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -32,10 +32,10 @@
if (!@isReadableByteStreamController(this))
throw @makeThisTypeError("ReadableByteStreamController", "enqueue");
- if (this.@closeRequested)
+ if (@getByIdDirectPrivate(this, "closeRequested"))
@throwTypeError("ReadableByteStreamController is requested to close");
- if (this.@controlledReadableStream.@state !== @streamReadable)
+ if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
@throwTypeError("ReadableStream is not readable");
if (!@isObject(chunk))
@@ -54,7 +54,7 @@
if (!@isReadableByteStreamController(this))
throw @makeThisTypeError("ReadableByteStreamController", "error");
- if (this.@controlledReadableStream.@state !== @streamReadable)
+ if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
@throwTypeError("ReadableStream is not readable");
@readableByteStreamControllerError(this, error);
@@ -67,10 +67,10 @@
if (!@isReadableByteStreamController(this))
throw @makeThisTypeError("ReadableByteStreamController", "close");
- if (this.@closeRequested)
+ if (@getByIdDirectPrivate(this, "closeRequested"))
@throwTypeError("Close has already been requested");
- if (this.@controlledReadableStream.@state !== @streamReadable)
+ if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
@throwTypeError("ReadableStream is not readable");
@readableByteStreamControllerClose(this);
@@ -84,15 +84,15 @@
if (!@isReadableByteStreamController(this))
throw @makeGetterTypeError("ReadableByteStreamController", "byobRequest");
- if (this.@byobRequest === @undefined && this.@pendingPullIntos.length) {
- const firstDescriptor = this.@pendingPullIntos[0];
+ if (@getByIdDirectPrivate(this, "byobRequest") === @undefined && @getByIdDirectPrivate(this, "pendingPullIntos").length) {
+ const firstDescriptor = @getByIdDirectPrivate(this, "pendingPullIntos")[0];
const view = new @Uint8Array(firstDescriptor.buffer,
firstDescriptor.byteOffset + firstDescriptor.bytesFilled,
firstDescriptor.byteLength - firstDescriptor.bytesFilled);
- this.@byobRequest = new @ReadableStreamBYOBRequest(this, view);
+ @putByIdDirectPrivate(this, "byobRequest", new @ReadableStreamBYOBRequest(this, view));
}
- return this.@byobRequest;
+ return @getByIdDirectPrivate(this, "byobRequest");
}
@getter
Modified: trunk/Source/WebCore/Modules/streams/ReadableByteStreamInternals.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableByteStreamInternals.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableByteStreamInternals.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -32,13 +32,13 @@
if (!@isReadableStream(stream))
@throwTypeError("ReadableStreamBYOBReader needs a ReadableStream");
- if (!@isReadableByteStreamController(stream.@readableStreamController))
+ if (!@isReadableByteStreamController(@getByIdDirectPrivate(stream, "readableStreamController")))
@throwTypeError("ReadableStreamBYOBReader needs a ReadableByteStreamController");
if (@isReadableStreamLocked(stream))
@throwTypeError("ReadableStream is locked");
@readableStreamReaderGenericInitialize(this, stream);
- this.@readIntoRequests = [];
+ @putByIdDirectPrivate(this, "readIntoRequests", []);
return this;
}
@@ -51,22 +51,22 @@
@throwTypeError("ReadableByteStreamController needs a ReadableStream");
// readableStreamController is initialized with null value.
- if (stream.@readableStreamController !== null)
+ if (@getByIdDirectPrivate(stream, "readableStreamController") !== null)
@throwTypeError("ReadableStream already has a controller");
- this.@controlledReadableStream = stream;
- this.@underlyingByteSource = underlyingByteSource;
- this.@pullAgain = false;
- this.@pulling = false;
+ @putByIdDirectPrivate(this, "controlledReadableStream", stream);
+ @putByIdDirectPrivate(this, "underlyingByteSource", underlyingByteSource);
+ @putByIdDirectPrivate(this, "pullAgain", false);
+ @putByIdDirectPrivate(this, "pulling", false);
@readableByteStreamControllerClearPendingPullIntos(this);
- this.@queue = @newQueue();
- this.@started = false;
- this.@closeRequested = false;
+ @putByIdDirectPrivate(this, "queue", @newQueue());
+ @putByIdDirectPrivate(this, "started", false);
+ @putByIdDirectPrivate(this, "closeRequested", false);
let hwm = @toNumber(highWaterMark);
if (@isNaN(hwm) || hwm < 0)
@throwRangeError("highWaterMark value is negative or not a number");
- this.@strategyHWM = hwm;
+ @putByIdDirectPrivate(this, "strategyHWM", hwm);
let autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
if (autoAllocateChunkSize !== @undefined) {
@@ -74,22 +74,22 @@
if (autoAllocateChunkSize <= 0 || autoAllocateChunkSize === @Number.POSITIVE_INFINITY || autoAllocateChunkSize === @Number.NEGATIVE_INFINITY)
@throwRangeError("autoAllocateChunkSize value is negative or equal to positive or negative infinity");
}
- this.@autoAllocateChunkSize = autoAllocateChunkSize;
- this.@pendingPullIntos = [];
+ @putByIdDirectPrivate(this, "autoAllocateChunkSize", autoAllocateChunkSize);
+ @putByIdDirectPrivate(this, "pendingPullIntos", []);
const controller = this;
const startResult = @promiseInvokeOrNoopNoCatch(underlyingByteSource, "start", [this]).@then(() => {
- controller.@started = true;
- @assert(!controller.@pulling);
- @assert(!controller.@pullAgain);
+ @putByIdDirectPrivate(controller, "started", true);
+ @assert(!@getByIdDirectPrivate(controller, "pulling"));
+ @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
@readableByteStreamControllerCallPullIfNeeded(controller);
}, (error) => {
- if (stream.@state === @streamReadable)
+ if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
@readableByteStreamControllerError(controller, error);
});
- this.@cancel = @readableByteStreamControllerCancel;
- this.@pull = @readableByteStreamControllerPull;
+ @putByIdDirectPrivate(this, "cancel", @readableByteStreamControllerCancel);
+ @putByIdDirectPrivate(this, "pull", @readableByteStreamControllerPull);
return this;
}
@@ -98,8 +98,8 @@
{
"use strict";
- this.@associatedReadableByteStreamController = controller;
- this.@view = view;
+ @putByIdDirectPrivate(this, "associatedReadableByteStreamController", controller);
+ @putByIdDirectPrivate(this, "view", view);
}
function isReadableByteStreamController(controller)
@@ -108,7 +108,7 @@
// Same test mechanism as in isReadableStreamDefaultController (ReadableStreamInternals.js).
// See corresponding function for explanations.
- return @isObject(controller) && !!controller.@underlyingByteSource;
+ return @isObject(controller) && !!@getByIdDirectPrivate(controller, "underlyingByteSource");
}
function isReadableStreamBYOBRequest(byobRequest)
@@ -117,7 +117,7 @@
// Same test mechanism as in isReadableStreamDefaultController (ReadableStreamInternals.js).
// See corresponding function for explanations.
- return @isObject(byobRequest) && !!byobRequest.@associatedReadableByteStreamController;
+ return @isObject(byobRequest) && !!@getByIdDirectPrivate(byobRequest, "associatedReadableByteStreamController");
}
function isReadableStreamBYOBReader(reader)
@@ -127,7 +127,7 @@
// Spec tells to return true only if reader has a readIntoRequests internal slot.
// However, since it is a private slot, it cannot be checked using hasOwnProperty().
// Since readIntoRequests is initialized with an empty array, the following test is ok.
- return @isObject(reader) && !!reader.@readIntoRequests;
+ return @isObject(reader) && !!@getByIdDirectPrivate(reader, "readIntoRequests");
}
function readableByteStreamControllerCancel(controller, reason)
@@ -134,10 +134,11 @@
{
"use strict";
- if (controller.@pendingPullIntos.length > 0)
- controller.@pendingPullIntos[0].bytesFilled = 0;
- controller.@queue = @newQueue();
- return @promiseInvokeOrNoop(controller.@underlyingByteSource, "cancel", [reason]);
+ var pendingPullIntos = @getByIdDirectPrivate(controller, "pendingPullIntos");
+ if (pendingPullIntos.length > 0)
+ pendingPullIntos[0].bytesFilled = 0;
+ @putByIdDirectPrivate(controller, "queue", @newQueue());
+ return @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingByteSource"), "cancel", [reason]);
}
function readableByteStreamControllerError(controller, e)
@@ -144,10 +145,10 @@
{
"use strict";
- @assert(controller.@controlledReadableStream.@state === @streamReadable);
+ @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable);
@readableByteStreamControllerClearPendingPullIntos(controller);
- controller.@queue = @newQueue();
- @readableStreamError(controller.@controlledReadableStream, e);
+ @putByIdDirectPrivate(controller, "queue", @newQueue());
+ @readableStreamError(@getByIdDirectPrivate(controller, "controlledReadableStream"), e);
}
function readableByteStreamControllerClose(controller)
@@ -154,16 +155,17 @@
{
"use strict";
- @assert(!controller.@closeRequested);
- @assert(controller.@controlledReadableStream.@state === @streamReadable);
+ @assert(!@getByIdDirectPrivate(controller, "closeRequested"));
+ @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable);
- if (controll...@queue.size > 0) {
- controller.@closeRequested = true;
+ if (@getByIdDirectPrivate(controller, "queue").size > 0) {
+ @putByIdDirectPrivate(controller, "closeRequested", true);
return;
}
- if (controller.@pendingPullIntos.length > 0) {
- if (controller.@pendingPullIntos[0].bytesFilled > 0) {
+ var pendingPullIntos = @getByIdDirectPrivate(controller, "pendingPullIntos");
+ if (pendingPullIntos.length > 0) {
+ if (pendingPullIntos[0].bytesFilled > 0) {
const e = new @TypeError("Close requested while there remain pending bytes");
@readableByteStreamControllerError(controller, e);
throw e;
@@ -170,7 +172,7 @@
}
}
- @readableStreamClose(controller.@controlledReadableStream);
+ @readableStreamClose(@getByIdDirectPrivate(controller, "controlledReadableStream"));
}
function readableByteStreamControllerClearPendingPullIntos(controller)
@@ -178,21 +180,22 @@
"use strict";
@readableByteStreamControllerInvalidateBYOBRequest(controller);
- controller.@pendingPullIntos = [];
+ @putByIdDirectPrivate(controller, "pendingPullIntos", []);
}
function readableByteStreamControllerGetDesiredSize(controller)
{
- "use strict";
+ "use strict";
- const stream = controller.@controlledReadableStream;
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
+ const state = @getByIdDirectPrivate(stream, "state");
- if (stream.@state === @streamErrored)
- return null;
- if (stream.@state === @streamClosed)
- return 0;
+ if (state === @streamErrored)
+ return null;
+ if (state === @streamClosed)
+ return 0;
- return controller.@strategyHWM - controll...@queue.size;
+ return @getByIdDirectPrivate(controller, "strategyHWM") - @getByIdDirectPrivate(controller, "queue").size;
}
function readableStreamHasBYOBReader(stream)
@@ -199,7 +202,8 @@
{
"use strict";
- return stream.@reader !== @undefined && @isReadableStreamBYOBReader(stream.@reader);
+ const reader = @getByIdDirectPrivate(stream, "reader");
+ return reader !== @undefined && @isReadableStreamBYOBReader(reader);
}
function readableStreamHasDefaultReader(stream)
@@ -206,7 +210,8 @@
{
"use strict";
- return stream.@reader !== @undefined && @isReadableStreamDefaultReader(stream.@reader);
+ const reader = @getByIdDirectPrivate(stream, "reader");
+ return reader !== @undefined && @isReadableStreamDefaultReader(reader);
}
function readableByteStreamControllerHandleQueueDrain(controller) {
@@ -213,9 +218,9 @@
"use strict";
- @assert(controller.@controlledReadableStream.@state === @streamReadable);
- if (!controll...@queue.size && controller.@closeRequested)
- @readableStreamClose(controller.@controlledReadableStream);
+ @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable);
+ if (!@getByIdDirectPrivate(controller, "queue").size && @getByIdDirectPrivate(controller, "closeRequested"))
+ @readableStreamClose(@getByIdDirectPrivate(controller, "controlledReadableStream"));
else
@readableByteStreamControllerCallPullIfNeeded(controller);
}
@@ -224,13 +229,13 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
@assert(@readableStreamHasDefaultReader(stream));
- if (controll...@queue.size > 0) {
- @assert(stream.@reader.@readRequests.length === 0);
- const entry = controller.@queue.content.@shift();
- controll...@queue.size -= entry.byteLength;
+ if (@getByIdDirectPrivate(controller, "queue").size > 0) {
+ @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length === 0);
+ const entry = @getByIdDirectPrivate(controller, "queue").content.@shift();
+ @getByIdDirectPrivate(controller, "queue").size -= entry.byteLength;
@readableByteStreamControllerHandleQueueDrain(controller);
let view;
try {
@@ -241,10 +246,10 @@
return @Promise.@resolve({value: view, done: false});
}
- if (controller.@autoAllocateChunkSize !== @undefined) {
+ if (@getByIdDirectPrivate(controller, "autoAllocateChunkSize") !== @undefined) {
let buffer;
try {
- buffer = new @ArrayBuffer(controller.@autoAllocateChunkSize);
+ buffer = new @ArrayBuffer(@getByIdDirectPrivate(controller, "autoAllocateChunkSize"));
} catch (error) {
return @Promise.@reject(error);
}
@@ -251,13 +256,13 @@
const pullIntoDescriptor = {
buffer,
byteOffset: 0,
- byteLength: controller.@autoAllocateChunkSize,
+ byteLength: @getByIdDirectPrivate(controller, "autoAllocateChunkSize"),
bytesFilled: 0,
elementSize: 1,
ctor: @Uint8Array,
readerType: 'default'
};
- controller.@pendingPullIntos.@push(pullIntoDescriptor);
+ @getByIdDirectPrivate(controller, "pendingPullIntos").@push(pullIntoDescriptor);
}
const promise = @readableStreamAddReadRequest(stream);
@@ -269,17 +274,17 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
- if (stream.@state !== @streamReadable)
+ if (@getByIdDirectPrivate(stream, "state") !== @streamReadable)
return false;
- if (controller.@closeRequested)
+ if (@getByIdDirectPrivate(controller, "closeRequested"))
return false;
- if (!controller.@started)
+ if (!@getByIdDirectPrivate(controller, "started"))
return false;
- if (@readableStreamHasDefaultReader(stream) && stream.@reader.@readRequests.length > 0)
+ if (@readableStreamHasDefaultReader(stream) && @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length > 0)
return true;
- if (@readableStreamHasBYOBReader(stream) && stream.@reader.@readIntoRequests.length > 0)
+ if (@readableStreamHasBYOBReader(stream) && @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readIntoRequests").length > 0)
return true;
if (@readableByteStreamControllerGetDesiredSize(controller) > 0)
return true;
@@ -293,21 +298,21 @@
if (!@readableByteStreamControllerShouldCallPull(controller))
return;
- if (controller.@pulling) {
- controller.@pullAgain = true;
+ if (@getByIdDirectPrivate(controller, "pulling")) {
+ @putByIdDirectPrivate(controller, "pullAgain", true);
return;
}
- @assert(!controller.@pullAgain);
- controller.@pulling = true;
- @promiseInvokeOrNoop(controller.@underlyingByteSource, "pull", [controller]).@then(() => {
- controller.@pulling = false;
- if (controller.@pullAgain) {
- controller.@pullAgain = false;
+ @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
+ @putByIdDirectPrivate(controller, "pulling", true);
+ @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingByteSource"), "pull", [controller]).@then(() => {
+ @putByIdDirectPrivate(controller, "pulling", false);
+ if (@getByIdDirectPrivate(controller, "pullAgain")) {
+ @putByIdDirectPrivate(controller, "pullAgain", false);
@readableByteStreamControllerCallPullIfNeeded(controller);
}
}, (error) => {
- if (controller.@controlledReadableStream.@state === @streamReadable)
+ if (@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable)
@readableByteStreamControllerError(controller, error);
});
}
@@ -327,9 +332,9 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
- @assert(!controller.@closeRequested);
- @assert(stream.@state === @streamReadable);
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
+ @assert(!@getByIdDirectPrivate(controller, "closeRequested"));
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
const buffer = chunk.buffer;
const byteOffset = chunk.byteOffset;
const byteLength = chunk.byteLength;
@@ -336,10 +341,10 @@
const transferredBuffer = @transferBufferToCurrentRealm(buffer);
if (@readableStreamHasDefaultReader(stream)) {
- if (!stream.@reader.@readRequests.length)
+ if (!@getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length)
@readableByteStreamControllerEnqueueChunk(controller, transferredBuffer, byteOffset, byteLength);
else {
- @assert(!controller.@queue.content.length);
+ @assert(!@getByIdDirectPrivate(controller, "queue").content.length);
let transferredView = new @Uint8Array(transferredBuffer, byteOffset, byteLength);
@readableStreamFulfillReadRequest(stream, transferredView, false);
}
@@ -361,12 +366,12 @@
{
"use strict";
- controller.@queue.content.@push({
+ @getByIdDirectPrivate(controller, "queue").content.@push({
buffer: buffer,
byteOffset: byteOffset,
byteLength: byteLength
});
- controll...@queue.size += byteLength;
+ @getByIdDirectPrivate(controller, "queue").size += byteLength;
}
function readableByteStreamControllerRespondWithNewView(controller, view)
@@ -373,9 +378,9 @@
{
"use strict";
- @assert(controller.@pendingPullIntos.length > 0);
+ @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length > 0);
- let firstDescriptor = controller.@pendingPullIntos[0];
+ let firstDescriptor = @getByIdDirectPrivate(controller, "pendingPullIntos")[0];
if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset)
@throwRangeError("Invalid value for view.byteOffset");
@@ -396,7 +401,7 @@
if (@isNaN(bytesWritten) || bytesWritten === @Number.POSITIVE_INFINITY || bytesWritten < 0 )
@throwRangeError("bytesWritten has an incorrect value");
- @assert(controller.@pendingPullIntos.length > 0);
+ @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length > 0);
@readableByteStreamControllerRespondInternal(controller, bytesWritten);
}
@@ -405,15 +410,15 @@
{
"use strict";
- let firstDescriptor = controller.@pendingPullIntos[0];
- let stream = controller.@controlledReadableStream;
+ let firstDescriptor = @getByIdDirectPrivate(controller, "pendingPullIntos")[0];
+ let stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
- if (stream.@state === @streamClosed) {
+ if (@getByIdDirectPrivate(stream, "state") === @streamClosed) {
if (bytesWritten !== 0)
@throwTypeError("bytesWritten is different from 0 even though stream is closed");
@readableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
} else {
- @assert(stream.@state === @streamReadable);
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
@readableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
}
}
@@ -425,7 +430,7 @@
if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength)
@throwRangeError("bytesWritten value is too great");
- @assert(controller.@pendingPullIntos.length === 0 || controller.@pendingPullIntos[0] === pullIntoDescriptor);
+ @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length === 0 || @getByIdDirectPrivate(controller, "pendingPullIntos")[0] === pullIntoDescriptor);
@readableByteStreamControllerInvalidateBYOBRequest(controller);
pullIntoDescriptor.bytesFilled += bytesWritten;
@@ -443,7 +448,7 @@
pullIntoDescriptor.buffer = @transferBufferToCurrentRealm(pullIntoDescriptor.buffer);
pullIntoDescriptor.bytesFilled -= remainderSize;
- @readableByteStreamControllerCommitDescriptor(controller.@controlledReadableStream, pullIntoDescriptor);
+ @readableByteStreamControllerCommitDescriptor(@getByIdDirectPrivate(controller, "controlledReadableStream"), pullIntoDescriptor);
@readableByteStreamControllerProcessPullDescriptors(controller);
}
@@ -454,10 +459,10 @@
firstDescriptor.buffer = @transferBufferToCurrentRealm(firstDescriptor.buffer);
@assert(firstDescriptor.bytesFilled === 0);
- if (@readableStreamHasBYOBReader(controller.@controlledReadableStream)) {
- while (controller.@controlledReadableStream.@reader.@readIntoRequests.length > 0) {
+ if (@readableStreamHasBYOBReader(@getByIdDirectPrivate(controller, "controlledReadableStream"))) {
+ while (@getByIdDirectPrivate(@getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "reader"), "readIntoRequests").length > 0) {
let pullIntoDescriptor = @readableByteStreamControllerShiftPendingDescriptor(controller);
- @readableByteStreamControllerCommitDescriptor(controller.@controlledReadableStream, pullIntoDescriptor);
+ @readableByteStreamControllerCommitDescriptor(@getByIdDirectPrivate(controller, "controlledReadableStream"), pullIntoDescriptor);
}
}
}
@@ -467,14 +472,14 @@
{
"use strict";
- @assert(!controller.@closeRequested);
- while (controller.@pendingPullIntos.length > 0) {
- if (controll...@queue.size === 0)
+ @assert(!@getByIdDirectPrivate(controller, "closeRequested"));
+ while (@getByIdDirectPrivate(controller, "pendingPullIntos").length > 0) {
+ if (@getByIdDirectPrivate(controller, "queue").size === 0)
return;
- let pullIntoDescriptor = controller.@pendingPullIntos[0];
+ let pullIntoDescriptor = @getByIdDirectPrivate(controller, "pendingPullIntos")[0];
if (@readableByteStreamControllerFillDescriptorFromQueue(controller, pullIntoDescriptor)) {
@readableByteStreamControllerShiftPendingDescriptor(controller);
- @readableByteStreamControllerCommitDescriptor(controller.@controlledReadableStream, pullIntoDescriptor);
+ @readableByteStreamControllerCommitDescriptor(@getByIdDirectPrivate(controller, "controlledReadableStream"), pullIntoDescriptor);
}
}
}
@@ -485,8 +490,8 @@
"use strict";
const currentAlignedBytes = pullIntoDescriptor.bytesFilled - (pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize);
- const maxBytesToCopy = controll...@queue.size < pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled ?
- controll...@queue.size : pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled;
+ const maxBytesToCopy = @getByIdDirectPrivate(controller, "queue").size < pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled ?
+ @getByIdDirectPrivate(controller, "queue").size : pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled;
const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
const maxAlignedBytes = maxBytesFilled - (maxBytesFilled % pullIntoDescriptor.elementSize);
let totalBytesToCopyRemaining = maxBytesToCopy;
@@ -498,7 +503,7 @@
}
while (totalBytesToCopyRemaining > 0) {
- let headOfQueue = controller.@queue.content[0];
+ let headOfQueue = @getByIdDirectPrivate(controller, "queue").content[0];
const bytesToCopy = totalBytesToCopyRemaining < headOfQueue.byteLength ? totalBytesToCopyRemaining : headOfQueue.byteLength;
// Copy appropriate part of pullIntoDescriptor.buffer to headOfQueue.buffer.
// Remark: this implementation is not completely aligned on the definition of CopyDataBlockBytes
@@ -509,14 +514,14 @@
new @Uint8Array(pullIntoDescriptor.buffer).set(new @Uint8Array(headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy), destStart);
if (headOfQueue.byteLength === bytesToCopy)
- controller.@queue.content.@shift();
+ @getByIdDirectPrivate(controller, "queue").content.@shift();
else {
headOfQueue.byteOffset += bytesToCopy;
headOfQueue.byteLength -= bytesToCopy;
}
- controll...@queue.size -= bytesToCopy;
- @assert(controller.@pendingPullIntos.length === 0 || controller.@pendingPullIntos[0] === pullIntoDescriptor);
+ @getByIdDirectPrivate(controller, "queue").size -= bytesToCopy;
+ @assert(@getByIdDirectPrivate(controller, "pendingPullIntos").length === 0 || @getByIdDirectPrivate(controller, "pendingPullIntos")[0] === pullIntoDescriptor);
@readableByteStreamControllerInvalidateBYOBRequest(controller);
pullIntoDescriptor.bytesFilled += bytesToCopy;
totalBytesToCopyRemaining -= bytesToCopy;
@@ -523,7 +528,7 @@
}
if (!ready) {
- @assert(controll...@queue.size === 0);
+ @assert(@getByIdDirectPrivate(controller, "queue").size === 0);
@assert(pullIntoDescriptor.bytesFilled > 0);
@assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);
}
@@ -536,7 +541,7 @@
{
"use strict";
- let descriptor = controller.@pendingPullIntos.@shift();
+ let descriptor = @getByIdDirectPrivate(controller, "pendingPullIntos").@shift();
@readableByteStreamControllerInvalidateBYOBRequest(controller);
return descriptor;
}
@@ -545,11 +550,12 @@
{
"use strict";
- if (controller.@byobRequest === @undefined)
+ if (@getByIdDirectPrivate(controller, "byobRequest") === @undefined)
return;
- controller.@byobRequest.@associatedReadableByteStreamController = @undefined;
- controller.@byobRequest.@view = @undefined;
- controller.@byobRequest = @undefined;
+ const byobRequest = @getByIdDirectPrivate(controller, "byobRequest");
+ @putByIdDirectPrivate(byobRequest, "associatedReadableByteStreamController", @undefined);
+ @putByIdDirectPrivate(byobRequest, "view", @undefined);
+ @putByIdDirectPrivate(controller, "byobRequest", @undefined);
}
// Spec name: readableByteStreamControllerCommitPullIntoDescriptor (shortened for readability).
@@ -557,9 +563,9 @@
{
"use strict";
- @assert(stream.@state !== @streamErrored);
+ @assert(@getByIdDirectPrivate(stream, "state") !== @streamErrored);
let done = false;
- if (stream.@state === @streamClosed) {
+ if (@getByIdDirectPrivate(stream, "state") === @streamClosed) {
@assert(!pullIntoDescriptor.bytesFilled);
done = true;
}
@@ -587,7 +593,7 @@
{
"use strict";
- stream.@reader.@readIntoRequests.@shift().@resolve.@call(@undefined, {value: chunk, done: done});
+ @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readIntoRequests").@shift().@resolve.@call(@undefined, {value: chunk, done: done});
}
function readableStreamBYOBReaderRead(reader, view)
@@ -594,14 +600,14 @@
{
"use strict";
- const stream = reader.@ownerReadableStream;
+ const stream = @getByIdDirectPrivate(reader, "ownerReadableStream");
@assert(!!stream);
- stream.@disturbed = true;
- if (stream.@state === @streamErrored)
- return @Promise.@reject(stream.@storedError);
+ @putByIdDirectPrivate(stream, "disturbed", true);
+ if (@getByIdDirectPrivate(stream, "state") === @streamErrored)
+ return @Promise.@reject(@getByIdDirectPrivate(stream, "storedError"));
- return @readableByteStreamControllerPullInto(stream.@readableStreamController, view);
+ return @readableByteStreamControllerPullInto(@getByIdDirectPrivate(stream, "readableStreamController"), view);
}
function readableByteStreamControllerPullInto(controller, view)
@@ -608,7 +614,7 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
let elementSize = 1;
// Spec describes that in the case where view is a TypedArray, elementSize
// should be set to the size of an element (e.g. 2 for UInt16Array). For
@@ -641,24 +647,24 @@
readerType: 'byob'
};
- if (controller.@pendingPullIntos.length) {
+ if (@getByIdDirectPrivate(controller, "pendingPullIntos").length) {
pullIntoDescriptor.buffer = @transferBufferToCurrentRealm(pullIntoDescriptor.buffer);
- controller.@pendingPullIntos.@push(pullIntoDescriptor);
+ @getByIdDirectPrivate(controller, "pendingPullIntos").@push(pullIntoDescriptor);
return @readableStreamAddReadIntoRequest(stream);
}
- if (stream.@state === @streamClosed) {
+ if (@getByIdDirectPrivate(stream, "state") === @streamClosed) {
const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
return @Promise.@resolve({ value: emptyView, done: true });
}
- if (controll...@queue.size > 0) {
+ if (@getByIdDirectPrivate(controller, "queue").size > 0) {
if (@readableByteStreamControllerFillDescriptorFromQueue(controller, pullIntoDescriptor)) {
const filledView = @readableByteStreamControllerConvertDescriptor(pullIntoDescriptor);
@readableByteStreamControllerHandleQueueDrain(controller);
return @Promise.@resolve({ value: filledView, done: false });
}
- if (controller.@closeRequested) {
+ if (@getByIdDirectPrivate(controller, "closeRequested")) {
const e = new @TypeError("Closing stream has been requested");
@readableByteStreamControllerError(controller, e);
return @Promise.@reject(e);
@@ -666,7 +672,7 @@
}
pullIntoDescriptor.buffer = @transferBufferToCurrentRealm(pullIntoDescriptor.buffer);
- controller.@pendingPullIntos.@push(pullIntoDescriptor);
+ @getByIdDirectPrivate(controller, "pendingPullIntos").@push(pullIntoDescriptor);
const promise = @readableStreamAddReadIntoRequest(stream);
@readableByteStreamControllerCallPullIfNeeded(controller);
return promise;
@@ -676,11 +682,11 @@
{
"use strict";
- @assert(@isReadableStreamBYOBReader(stream.@reader));
- @assert(stream.@state === @streamReadable || stream.@state === @streamClosed);
+ @assert(@isReadableStreamBYOBReader(@getByIdDirectPrivate(stream, "reader")));
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable || @getByIdDirectPrivate(stream, "state") === @streamClosed);
const readRequest = @newPromiseCapability(@Promise);
- stream.@reader.@readIntoRequests.@push(readRequest);
+ @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readIntoRequests").@push(readRequest);
return readRequest.@promise;
}
Modified: trunk/Source/WebCore/Modules/streams/ReadableStream.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableStream.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableStream.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -41,15 +41,15 @@
if (strategy !== @undefined && !@isObject(strategy))
@throwTypeError("ReadableStream constructor takes an object as second argument, if any");
- this.@state = @streamReadable;
- this.@reader = @undefined;
- this.@storedError = @undefined;
- this.@disturbed = false;
+ @putByIdDirectPrivate(this, "state", @streamReadable);
+ @putByIdDirectPrivate(this, "reader", @undefined);
+ @putByIdDirectPrivate(this, "storedError", @undefined);
+ @putByIdDirectPrivate(this, "disturbed", false);
// Initialized with null value to enable distinction with undefined case.
- this.@readableStreamController = null;
+ @putByIdDirectPrivate(this, "readableStreamController", null);
const type = underlyingSource.type;
- const typeString = @String(type);
+ const typeString = @toString(type);
if (typeString === "bytes") {
if (!@readableByteStreamAPIEnabled())
@@ -61,11 +61,11 @@
@throwRangeError("Strategy for a ReadableByteStreamController cannot have a size");
let readableByteStreamControllerConstructor = @ReadableByteStreamController;
- this.@readableStreamController = new @ReadableByteStreamController(this, underlyingSource, strategy.highWaterMark);
+ @putByIdDirectPrivate(this, "readableStreamController", new @ReadableByteStreamController(this, underlyingSource, strategy.highWaterMark));
} else if (type === @undefined) {
if (strategy.highWaterMark === @undefined)
strategy.highWaterMark = 1;
- this.@readableStreamController = new @ReadableStreamDefaultController(this, underlyingSource, strategy.size, strategy.highWaterMark);
+ @putByIdDirectPrivate(this, "readableStreamController", new @ReadableStreamDefaultController(this, underlyingSource, strategy.size, strategy.highWaterMark));
} else
@throwRangeError("Invalid type for underlying source");
@@ -113,7 +113,7 @@
const readable = streams.readable;
const promise = this.pipeTo(writable, options);
if (@isPromise(promise))
- promise.@promiseIsHandled = true;
+ @putByIdDirectPrivate(promise, "promiseIsHandled", true);
return readable;
}
Modified: trunk/Source/WebCore/Modules/streams/ReadableStreamBYOBReader.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableStreamBYOBReader.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableStreamBYOBReader.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -31,7 +31,7 @@
if (!@isReadableStreamBYOBReader(this))
return @Promise.@reject(@makeThisTypeError("ReadableStreamBYOBReader", "cancel"));
- if (!this.@ownerReadableStream)
+ if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
return @Promise.@reject(new @TypeError("cancel() called on a reader owned by no readable stream"));
return @readableStreamReaderGenericCancel(this, reason);
@@ -44,7 +44,7 @@
if (!@isReadableStreamBYOBReader(this))
return @Promise.@reject(@makeThisTypeError("ReadableStreamBYOBReader", "read"));
- if (!this.@ownerReadableStream)
+ if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
return @Promise.@reject(new @TypeError("read() called on a reader owned by no readable stream"));
if (!@isObject(view))
@@ -66,10 +66,10 @@
if (!@isReadableStreamBYOBReader(this))
throw @makeThisTypeError("ReadableStreamBYOBReader", "releaseLock");
- if (!this.@ownerReadableStream)
+ if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
return;
- if (this.@readIntoRequests.length)
+ if (@getByIdDirectPrivate(this, "readIntoRequests").length)
@throwTypeError("There are still pending read requests, cannot release the lock");
@readableStreamReaderGenericRelease(this);
@@ -83,5 +83,5 @@
if (!@isReadableStreamBYOBReader(this))
return @Promise.@reject(@makeGetterTypeError("ReadableStreamBYOBReader", "closed"));
- return this.@closedPromiseCapability.@promise;
+ return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
}
Modified: trunk/Source/WebCore/Modules/streams/ReadableStreamBYOBRequest.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableStreamBYOBRequest.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableStreamBYOBRequest.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -32,10 +32,10 @@
if (!@isReadableStreamBYOBRequest(this))
throw @makeThisTypeError("ReadableStreamBYOBRequest", "respond");
- if (this.@associatedReadableByteStreamController === @undefined)
+ if (@getByIdDirectPrivate(this, "associatedReadableByteStreamController") === @undefined)
@throwTypeError("ReadableStreamBYOBRequest.associatedReadableByteStreamController is undefined");
- return @readableByteStreamControllerRespond(this.@associatedReadableByteStreamController, bytesWritten);
+ return @readableByteStreamControllerRespond(@getByIdDirectPrivate(this, "associatedReadableByteStreamController"), bytesWritten);
}
function respondWithNewView(view)
@@ -45,7 +45,7 @@
if (!@isReadableStreamBYOBRequest(this))
throw @makeThisTypeError("ReadableStreamBYOBRequest", "respond");
- if (this.@associatedReadableByteStreamController === @undefined)
+ if (@getByIdDirectPrivate(this, "associatedReadableByteStreamController") === @undefined)
@throwTypeError("ReadableStreamBYOBRequest.associatedReadableByteStreamController is undefined");
if (!@isObject(view))
@@ -54,7 +54,7 @@
if (!@ArrayBuffer.@isView(view))
@throwTypeError("Provided view is not an ArrayBufferView");
- return @readableByteStreamControllerRespondWithNewView(this.@associatedReadableByteStreamController, view);
+ return @readableByteStreamControllerRespondWithNewView(@getByIdDirectPrivate(this, "associatedReadableByteStreamController"), view);
}
@getter
@@ -65,5 +65,5 @@
if (!@isReadableStreamBYOBRequest(this))
throw @makeGetterTypeError("ReadableStreamBYOBRequest", "view");
- return this.@view;
+ return @getByIdDirectPrivate(this, "view");
}
Modified: trunk/Source/WebCore/Modules/streams/ReadableStreamDefaultController.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableStreamDefaultController.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableStreamDefaultController.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -45,7 +45,7 @@
if (!@isReadableStreamDefaultController(this))
throw @makeThisTypeError("ReadableStreamDefaultController", "error");
- if (this.@controlledReadableStream.@state !== @streamReadable)
+ if (@getByIdDirectPrivate(@getByIdDirectPrivate(this, "controlledReadableStream"), "state") !== @streamReadable)
@throwTypeError("ReadableStream is not readable");
@readableStreamDefaultControllerError(this, error);
Modified: trunk/Source/WebCore/Modules/streams/ReadableStreamDefaultReader.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableStreamDefaultReader.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableStreamDefaultReader.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -32,7 +32,7 @@
if (!@isReadableStreamDefaultReader(this))
return @Promise.@reject(@makeThisTypeError("ReadableStreamDefaultReader", "cancel"));
- if (!this.@ownerReadableStream)
+ if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
return @Promise.@reject(new @TypeError("cancel() called on a reader owned by no readable stream"));
return @readableStreamReaderGenericCancel(this, reason);
@@ -44,7 +44,7 @@
if (!@isReadableStreamDefaultReader(this))
return @Promise.@reject(@makeThisTypeError("ReadableStreamDefaultReader", "read"));
- if (!this.@ownerReadableStream)
+ if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
return @Promise.@reject(new @TypeError("read() called on a reader owned by no readable stream"));
return @readableStreamDefaultReaderRead(this);
@@ -57,10 +57,10 @@
if (!@isReadableStreamDefaultReader(this))
throw @makeThisTypeError("ReadableStreamDefaultReader", "releaseLock");
- if (!this.@ownerReadableStream)
+ if (!@getByIdDirectPrivate(this, "ownerReadableStream"))
return;
- if (this.@readRequests.length)
+ if (@getByIdDirectPrivate(this, "readRequests").length)
@throwTypeError("There are still pending read requests, cannot release the lock");
@readableStreamReaderGenericRelease(this);
@@ -74,5 +74,5 @@
if (!@isReadableStreamDefaultReader(this))
return @Promise.@reject(@makeGetterTypeError("ReadableStreamDefaultReader", "closed"));
- return this.@closedPromiseCapability.@promise;
+ return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
}
Modified: trunk/Source/WebCore/Modules/streams/ReadableStreamInternals.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/ReadableStreamInternals.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/ReadableStreamInternals.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -37,7 +37,7 @@
@throwTypeError("ReadableStream is locked");
@readableStreamReaderGenericInitialize(this, stream);
- this.@readRequests = [];
+ @putByIdDirectPrivate(this, "readRequests", []);
return this;
}
@@ -46,15 +46,15 @@
{
"use strict";
- reader.@ownerReadableStream = stream;
- stream.@reader = reader;
- if (stream.@state === @streamReadable)
- reader.@closedPromiseCapability = @newPromiseCapability(@Promise);
- else if (stream.@state === @streamClosed)
- reader.@closedPromiseCapability = { @promise: @Promise.@resolve() };
+ @putByIdDirectPrivate(reader, "ownerReadableStream", stream);
+ @putByIdDirectPrivate(stream, "reader", reader);
+ if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
+ @putByIdDirectPrivate(reader, "closedPromiseCapability", @newPromiseCapability(@Promise));
+ else if (@getByIdDirectPrivate(stream, "state") === @streamClosed)
+ @putByIdDirectPrivate(reader, "closedPromiseCapability", { @promise: @Promise.@resolve() });
else {
- @assert(stream.@state === @streamErrored);
- reader.@closedPromiseCapability = { @promise: @newHandledRejectedPromise(stream.@storedError) };
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamErrored);
+ @putByIdDirectPrivate(reader, "closedPromiseCapability", { @promise: @newHandledRejectedPromise(@getByIdDirectPrivate(stream, "storedError")) });
}
}
@@ -66,32 +66,32 @@
@throwTypeError("ReadableStreamDefaultController needs a ReadableStream");
// readableStreamController is initialized with null value.
- if (stream.@readableStreamController !== null)
+ if (@getByIdDirectPrivate(stream, "readableStreamController") !== null)
@throwTypeError("ReadableStream already has a controller");
- this.@controlledReadableStream = stream;
- this.@underlyingSource = underlyingSource;
- this.@queue = @newQueue();
- this.@started = false;
- this.@closeRequested = false;
- this.@pullAgain = false;
- this.@pulling = false;
- this.@strategy = @validateAndNormalizeQueuingStrategy(size, highWaterMark);
+ @putByIdDirectPrivate(this, "controlledReadableStream", stream);
+ @putByIdDirectPrivate(this, "underlyingSource", underlyingSource);
+ @putByIdDirectPrivate(this, "queue", @newQueue());
+ @putByIdDirectPrivate(this, "started", false);
+ @putByIdDirectPrivate(this, "closeRequested", false);
+ @putByIdDirectPrivate(this, "pullAgain", false);
+ @putByIdDirectPrivate(this, "pulling", false);
+ @putByIdDirectPrivate(this, "strategy", @validateAndNormalizeQueuingStrategy(size, highWaterMark));
const controller = this;
@promiseInvokeOrNoopNoCatch(underlyingSource, "start", [this]).@then(() => {
- controller.@started = true;
- @assert(!controller.@pulling);
- @assert(!controller.@pullAgain);
+ @putByIdDirectPrivate(controller, "started", true);
+ @assert(!@getByIdDirectPrivate(controller, "pulling"));
+ @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
@readableStreamDefaultControllerCallPullIfNeeded(controller);
}, (error) => {
- if (stream.@state === @streamReadable)
+ if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
@readableStreamDefaultControllerError(controller, error);
});
- this.@cancel = @readableStreamDefaultControllerCancel;
+ @putByIdDirectPrivate(this, "cancel", @readableStreamDefaultControllerCancel);
- this.@pull = @readableStreamDefaultControllerPull;
+ @putByIdDirectPrivate(this, "pull", @readableStreamDefaultControllerPull);
return this;
}
@@ -100,9 +100,9 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
- @assert(stream.@state === @streamReadable);
- controller.@queue = @newQueue();
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
+ @putByIdDirectPrivate(controller, "queue", @newQueue());
@readableStreamError(stream, error);
}
@@ -113,7 +113,7 @@
const reader = new @ReadableStreamDefaultReader(stream);
- reader.@closedPromiseCapability.@promise.@then(() => { }, (e) => { sink.error(e); });
+ @getByIdDirectPrivate(reader, "closedPromiseCapability").@promise.@then(() => { }, (e) => { sink.error(e); });
function doPipe() {
@readableStreamDefaultReaderRead(reader).@then(function(result) {
@@ -163,7 +163,7 @@
"cancel": @readableStreamTeeBranch2CancelFunction(teeState, stream)
});
- reader.@closedPromiseCapability.@promise.@then(@undefined, function(e) {
+ @getByIdDirectPrivate(reader, "closedPromiseCapability").@promise.@then(@undefined, function(e) {
if (teeState.closedOrErrored)
return;
@readableStreamDefaultControllerError(branch1.@readableStreamController, e);
@@ -258,7 +258,7 @@
// Spec tells to return true only if stream has a readableStreamController internal slot.
// However, since it is a private slot, it cannot be checked using hasOwnProperty().
// Therefore, readableStreamController is initialized with null value.
- return @isObject(stream) && stream.@readableStreamController !== @undefined;
+ return @isObject(stream) && @getByIdDirectPrivate(stream, "readableStreamController") !== @undefined;
}
function isReadableStreamDefaultReader(reader)
@@ -268,7 +268,7 @@
// Spec tells to return true only if reader has a readRequests internal slot.
// However, since it is a private slot, it cannot be checked using hasOwnProperty().
// Since readRequests is initialized with an empty array, the following test is ok.
- return @isObject(reader) && !!reader.@readRequests;
+ return @isObject(reader) && !!@getByIdDirectPrivate(reader, "readRequests");
}
function isReadableStreamDefaultController(controller)
@@ -279,7 +279,7 @@
// However, since it is a private slot, it cannot be checked using hasOwnProperty().
// underlyingSource is obtained in ReadableStream constructor: if undefined, it is set
// to an empty object. Therefore, following test is ok.
- return @isObject(controller) && !!controller.@underlyingSource;
+ return @isObject(controller) && !!@getByIdDirectPrivate(controller, "underlyingSource");
}
function readableStreamError(stream, error)
@@ -287,30 +287,30 @@
"use strict";
@assert(@isReadableStream(stream));
- @assert(stream.@state === @streamReadable);
- stream.@state = @streamErrored;
- stream.@storedError = error;
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
+ @putByIdDirectPrivate(stream, "state", @streamErrored);
+ @putByIdDirectPrivate(stream, "storedError", error);
- if (!stream.@reader)
+ if (!@getByIdDirectPrivate(stream, "reader"))
return;
- const reader = stream.@reader;
+ const reader = @getByIdDirectPrivate(stream, "reader");
if (@isReadableStreamDefaultReader(reader)) {
- const requests = reader.@readRequests;
+ const requests = @getByIdDirectPrivate(reader, "readRequests");
for (let index = 0, length = requests.length; index < length; ++index)
requests[index].@reject.@call(@undefined, error);
- reader.@readRequests = [];
+ @putByIdDirectPrivate(reader, "readRequests", []);
} else {
@assert(@isReadableStreamBYOBReader(reader));
- const requests = reader.@readIntoRequests;
+ const requests = @getByIdDirectPrivate(reader, "readIntoRequests");
for (let index = 0, length = requests.length; index < length; ++index)
requests[index].@reject.@call(@undefined, error);
- reader.@readIntoRequests = [];
+ @putByIdDirectPrivate(reader, "readIntoRequests", []);
}
- reader.@closedPromiseCapability.@reject.@call(@undefined, error);
- reader.@closedPromiseCapability.@promise.@promiseIsHandled = true;
+ @getByIdDirectPrivate(reader, "closedPromiseCapability").@reject.@call(@undefined, error);
+ @putByIdDirectPrivate(@getByIdDirectPrivate(reader, "closedPromiseCapability").@promise, "promiseIsHandled", true);
}
function readableStreamDefaultControllerCallPullIfNeeded(controller)
@@ -317,31 +317,31 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
if (!@readableStreamDefaultControllerCanCloseOrEnqueue(controller))
return;
- if (!controller.@started)
+ if (!@getByIdDirectPrivate(controller, "started"))
return;
- if ((!@isReadableStreamLocked(stream) || !stream.@reader.@readRequests.length) && @readableStreamDefaultControllerGetDesiredSize(controller) <= 0)
+ if ((!@isReadableStreamLocked(stream) || !@getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length) && @readableStreamDefaultControllerGetDesiredSize(controller) <= 0)
return;
- if (controller.@pulling) {
- controller.@pullAgain = true;
+ if (@getByIdDirectPrivate(controller, "pulling")) {
+ @putByIdDirectPrivate(controller, "pullAgain", true);
return;
}
- @assert(!controller.@pullAgain);
- controller.@pulling = true;
+ @assert(!@getByIdDirectPrivate(controller, "pullAgain"));
+ @putByIdDirectPrivate(controller, "pulling", true);
- @promiseInvokeOrNoop(controller.@underlyingSource, "pull", [controller]).@then(function() {
- controller.@pulling = false;
- if (controller.@pullAgain) {
- controller.@pullAgain = false;
+ @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingSource"), "pull", [controller]).@then(function() {
+ @putByIdDirectPrivate(controller, "pulling", false);
+ if (@getByIdDirectPrivate(controller, "pullAgain")) {
+ @putByIdDirectPrivate(controller, "pullAgain", false);
@readableStreamDefaultControllerCallPullIfNeeded(controller);
}
}, function(error) {
- if (stream.@state === @streamReadable)
+ if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
@readableStreamDefaultControllerError(controller, error);
});
}
@@ -351,7 +351,7 @@
"use strict";
@assert(@isReadableStream(stream));
- return !!stream.@reader;
+ return !!@getByIdDirectPrivate(stream, "reader");
}
function readableStreamDefaultControllerGetDesiredSize(controller)
@@ -358,14 +358,15 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
+ const state = @getByIdDirectPrivate(stream, "state");
- if (stream.@state === @streamErrored)
- return null;
- if (stream.@state === @streamClosed)
- return 0;
+ if (state === @streamErrored)
+ return null;
+ if (state === @streamClosed)
+ return 0;
- return controller.@strategy.highWaterMark - controll...@queue.size;
+ return @getByIdDirectPrivate(controller, "strategy").highWaterMark - @getByIdDirectPrivate(controller, "queue").size;
}
@@ -373,7 +374,7 @@
{
"use strict";
- const stream = reader.@ownerReadableStream;
+ const stream = @getByIdDirectPrivate(reader, "ownerReadableStream");
@assert(!!stream);
return @readableStreamCancel(stream, reason);
}
@@ -382,13 +383,14 @@
{
"use strict";
- stream.@disturbed = true;
- if (stream.@state === @streamClosed)
+ @putByIdDirectPrivate(stream, "disturbed", true);
+ const state = @getByIdDirectPrivate(stream, "state");
+ if (state === @streamClosed)
return @Promise.@resolve();
- if (stream.@state === @streamErrored)
- return @Promise.@reject(stream.@storedError);
+ if (state === @streamErrored)
+ return @Promise.@reject(@getByIdDirectPrivate(stream, "storedError"));
@readableStreamClose(stream);
- return stream.@readableStreamController.@cancel(stream.@readableStreamController, reason).@then(function() { });
+ return @getByIdDirectPrivate(stream, "readableStreamController").@cancel(@getByIdDirectPrivate(stream, "readableStreamController"), reason).@then(function() { });
}
function readableStreamDefaultControllerCancel(controller, reason)
@@ -395,8 +397,8 @@
{
"use strict";
- controller.@queue = @newQueue();
- return @promiseInvokeOrNoop(controller.@underlyingSource, "cancel", [reason]);
+ @putByIdDirectPrivate(controller, "queue", @newQueue());
+ return @promiseInvokeOrNoop(@getByIdDirectPrivate(controller, "underlyingSource"), "cancel", [reason]);
}
function readableStreamDefaultControllerPull(controller)
@@ -403,10 +405,10 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
- if (controller.@queue.content.length) {
- const chunk = @dequeueValue(controller.@queue);
- if (controller.@closeRequested && controller.@queue.content.length === 0)
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
+ if (@getByIdDirectPrivate(controller, "queue").content.length) {
+ const chunk = @dequeueValue(@getByIdDirectPrivate(controller, "queue"));
+ if (@getByIdDirectPrivate(controller, "closeRequested") && @getByIdDirectPrivate(controller, "queue").content.length === 0)
@readableStreamClose(stream);
else
@readableStreamDefaultControllerCallPullIfNeeded(controller);
@@ -422,9 +424,9 @@
"use strict";
@assert(@readableStreamDefaultControllerCanCloseOrEnqueue(controller));
- controller.@closeRequested = true;
- if (controller.@queue.content.length === 0)
- @readableStreamClose(controller.@controlledReadableStream);
+ @putByIdDirectPrivate(controller, "closeRequested", true);
+ if (@getByIdDirectPrivate(controller, "queue").content.length === 0)
+ @readableStreamClose(@getByIdDirectPrivate(controller, "controlledReadableStream"));
}
function readableStreamClose(stream)
@@ -431,21 +433,21 @@
{
"use strict";
- @assert(stream.@state === @streamReadable);
- stream.@state = @streamClosed;
- const reader = stream.@reader;
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamReadable);
+ @putByIdDirectPrivate(stream, "state", @streamClosed);
+ const reader = @getByIdDirectPrivate(stream, "reader");
if (!reader)
return;
if (@isReadableStreamDefaultReader(reader)) {
- const requests = reader.@readRequests;
+ const requests = @getByIdDirectPrivate(reader, "readRequests");
for (let index = 0, length = requests.length; index < length; ++index)
requests[index].@resolve.@call(@undefined, {value:@undefined, done: true});
- reader.@readRequests = [];
+ @putByIdDirectPrivate(reader, "readRequests", []);
}
- reader.@closedPromiseCapability.@resolve.@call();
+ @getByIdDirectPrivate(reader, "closedPromiseCapability").@resolve.@call();
}
function readableStreamFulfillReadRequest(stream, chunk, done)
@@ -452,7 +454,7 @@
{
"use strict";
- stream.@reader.@readRequests.@shift().@resolve.@call(@undefined, {value: chunk, done: done});
+ @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").@shift().@resolve.@call(@undefined, {value: chunk, done: done});
}
function readableStreamDefaultControllerEnqueue(controller, chunk)
@@ -459,10 +461,10 @@
{
"use strict";
- const stream = controller.@controlledReadableStream;
+ const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
@assert(@readableStreamDefaultControllerCanCloseOrEnqueue(controller));
- if (@isReadableStreamLocked(stream) && stream.@reader.@readRequests.length) {
+ if (@isReadableStreamLocked(stream) && @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").length) {
@readableStreamFulfillReadRequest(stream, chunk, false);
@readableStreamDefaultControllerCallPullIfNeeded(controller);
return;
@@ -470,12 +472,12 @@
try {
let chunkSize = 1;
- if (controll...@strategy.size !== @undefined)
- chunkSize = controll...@strategy.size(chunk);
- @enqueueValueWithSize(controller.@queue, chunk, chunkSize);
+ if (@getByIdDirectPrivate(controller, "strategy").size !== @undefined)
+ chunkSize = @getByIdDirectPrivate(controller, "strategy").size(chunk);
+ @enqueueValueWithSize(@getByIdDirectPrivate(controller, "queue"), chunk, chunkSize);
}
catch(error) {
- if (stream.@state === @streamReadable)
+ if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
@readableStreamDefaultControllerError(controller, error);
throw error;
}
@@ -486,17 +488,18 @@
{
"use strict";
- const stream = reader.@ownerReadableStream;
+ const stream = @getByIdDirectPrivate(reader, "ownerReadableStream");
@assert(!!stream);
+ const state = @getByIdDirectPrivate(stream, "state");
- stream.@disturbed = true;
- if (stream.@state === @streamClosed)
+ @putByIdDirectPrivate(stream, "disturbed", true);
+ if (state === @streamClosed)
return @Promise.@resolve({value: @undefined, done: true});
- if (stream.@state === @streamErrored)
- return @Promise.@reject(stream.@storedError);
- @assert(stream.@state === @streamReadable);
+ if (state === @streamErrored)
+ return @Promise.@reject(@getByIdDirectPrivate(stream, "storedError"));
+ @assert(state === @streamReadable);
- return stream.@readableStreamController.@pull(stream.@readableStreamController);
+ return @getByIdDirectPrivate(stream, "readableStreamController").@pull(@getByIdDirectPrivate(stream, "readableStreamController"));
}
function readableStreamAddReadRequest(stream)
@@ -503,11 +506,11 @@
{
"use strict";
- @assert(@isReadableStreamDefaultReader(stream.@reader));
- @assert(stream.@state == @streamReadable);
+ @assert(@isReadableStreamDefaultReader(@getByIdDirectPrivate(stream, "reader")));
+ @assert(@getByIdDirectPrivate(stream, "state") == @streamReadable);
const readRequest = @newPromiseCapability(@Promise);
- stream.@reader.@readRequests.@push(readRequest);
+ @getByIdDirectPrivate(@getByIdDirectPrivate(stream, "reader"), "readRequests").@push(readRequest);
return readRequest.@promise;
}
@@ -517,7 +520,7 @@
"use strict";
@assert(@isReadableStream(stream));
- return stream.@disturbed;
+ return @getByIdDirectPrivate(stream, "disturbed");
}
function readableStreamReaderGenericRelease(reader)
@@ -524,17 +527,17 @@
{
"use strict";
- @assert(!!reader.@ownerReadableStream);
- @assert(reader.@ownerReadableStream.@reader === reader);
+ @assert(!!@getByIdDirectPrivate(reader, "ownerReadableStream"));
+ @assert(@getByIdDirectPrivate(@getByIdDirectPrivate(reader, "ownerReadableStream"), "reader") === reader);
- if (reader.@ownerReadableStream.@state === @streamReadable)
- reader.@closedPromiseCapability.@reject.@call(@undefined, new @TypeError("releasing lock of reader whose stream is still in readable state"));
+ if (@getByIdDirectPrivate(@getByIdDirectPrivate(reader, "ownerReadableStream"), "state") === @streamReadable)
+ @getByIdDirectPrivate(reader, "closedPromiseCapability").@reject.@call(@undefined, new @TypeError("releasing lock of reader whose stream is still in readable state"));
else
- reader.@closedPromiseCapability = { @promise: @newHandledRejectedPromise(new @TypeError("reader released lock")) };
+ @putByIdDirectPrivate(reader, "closedPromiseCapability", { @promise: @newHandledRejectedPromise(new @TypeError("reader released lock")) });
- reader.@closedPromiseCapability.@promise.@promiseIsHandled = true;
- reader.@ownerReadableStream.@reader = @undefined;
- reader.@ownerReadableStream = @undefined;
+ @putByIdDirectPrivate(@getByIdDirectPrivate(reader, "closedPromiseCapability").@promise, "promiseIsHandled", true);
+ @putByIdDirectPrivate(@getByIdDirectPrivate(reader, "ownerReadableStream"), "reader", @undefined);
+ @putByIdDirectPrivate(reader, "ownerReadableStream", @undefined);
}
function readableStreamDefaultControllerCanCloseOrEnqueue(controller)
@@ -541,5 +544,5 @@
{
"use strict";
- return !controller.@closeRequested && controller.@controlledReadableStream.@state === @streamReadable;
+ return !@getByIdDirectPrivate(controller, "closeRequested") && @getByIdDirectPrivate(@getByIdDirectPrivate(controller, "controlledReadableStream"), "state") === @streamReadable;
}
Modified: trunk/Source/WebCore/Modules/streams/StreamInternals.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/StreamInternals.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/StreamInternals.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -81,11 +81,11 @@
if (size !== @undefined && typeof size !== "function")
@throwTypeError("size parameter must be a function");
- const normalizedStrategy = { };
+ const normalizedStrategy = {
+ size: size,
+ highWaterMark: @toNumber(highWaterMark)
+ };
- normalizedStrategy.size = size;
- normalizedStrategy.highWaterMark = @toNumber(highWaterMark);
-
if (@isNaN(normalizedStrategy.highWaterMark) || normalizedStrategy.highWaterMark < 0)
@throwRangeError("highWaterMark value is negative or not a number");
Modified: trunk/Source/WebCore/Modules/streams/WritableStream.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/WritableStream.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/WritableStream.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -41,15 +41,15 @@
if (!@isObject(strategy))
@throwTypeError("WritableStream constructor takes an object as second argument, if any");
- this.@underlyingSink = underlyingSink;
- this.@closedPromiseCapability = @newPromiseCapability(@Promise);
- this.@readyPromiseCapability = { @promise: @Promise.@resolve() };
- this.@queue = @newQueue();
- this.@state = @streamWritable;
- this.@started = false;
- this.@writing = false;
+ @putByIdDirectPrivate(this, "underlyingSink", underlyingSink);
+ @putByIdDirectPrivate(this, "closedPromiseCapability", @newPromiseCapability(@Promise));
+ @putByIdDirectPrivate(this, "readyPromiseCapability", { @promise: @Promise.@resolve() });
+ @putByIdDirectPrivate(this, "queue", @newQueue());
+ @putByIdDirectPrivate(this, "state", @streamWritable);
+ @putByIdDirectPrivate(this, "started", false);
+ @putByIdDirectPrivate(this, "writing", false);
- this.@strategy = @validateAndNormalizeQueuingStrategy(strategy.size, strategy.highWaterMark);
+ @putByIdDirectPrivate(this, "strategy", @validateAndNormalizeQueuingStrategy(strategy.size, strategy.highWaterMark));
@syncWritableStreamStateWithQueue(this);
@@ -56,10 +56,10 @@
const errorFunction = (e) => {
@errorWritableStream(this, e);
};
- this.@startedPromise = @promiseInvokeOrNoopNoCatch(underlyingSink, "start", [errorFunction]);
- this.@startedPromise.@then(() => {
- this.@started = true;
- this.@startedPromise = @undefined;
+ @putByIdDirectPrivate(this, "startedPromise", @promiseInvokeOrNoopNoCatch(underlyingSink, "start", [errorFunction]));
+ @getByIdDirectPrivate(this, "startedPromise").@then(() => {
+ @putByIdDirectPrivate(this, "started", true);
+ @putByIdDirectPrivate(this, "startedPromise", @undefined);
}, errorFunction);
return this;
@@ -72,15 +72,16 @@
if (!@isWritableStream(this))
return @Promise.@reject(new @TypeError("The WritableStream.abort method can only be used on instances of WritableStream"));
- if (this.@state === @streamClosed)
+ const state = @getByIdDirectPrivate(this, "state");
+ if (state === @streamClosed)
return @Promise.@resolve();
- if (this.@state === @streamErrored)
- return @Promise.@reject(this.@storedError);
+ if (state === @streamErrored)
+ return @Promise.@reject(@getByIdDirectPrivate(this, "storedError"));
@errorWritableStream(this, reason);
- return @promiseInvokeOrFallbackOrNoop(this.@underlyingSink, "abort", [reason], "close", []).@then(function() { });
+ return @promiseInvokeOrFallbackOrNoop(@getByIdDirectPrivate(this, "underlyingSink"), "abort", [reason], "close", []).@then(function() { });
}
function close()
@@ -90,20 +91,21 @@
if (!@isWritableStream(this))
return @Promise.@reject(new @TypeError("The WritableStream.close method can only be used on instances of WritableStream"));
- if (this.@state === @streamClosed || this.@state === @streamClosing)
+ const state = @getByIdDirectPrivate(this, "state");
+ if (state === @streamClosed || state === @streamClosing)
return @Promise.@reject(new @TypeError("Cannot close a WritableString that is closed or closing"));
- if (this.@state === @streamErrored)
- return @Promise.@reject(this.@storedError);
+ if (state === @streamErrored)
+ return @Promise.@reject(@getByIdDirectPrivate(this, "storedError"));
- if (this.@state === @streamWaiting)
- this.@readyPromiseCapability.@resolve.@call();
+ if (state === @streamWaiting)
+ @getByIdDirectPrivate(this, "readyPromiseCapability").@resolve.@call();
- this.@state = @streamClosing;
- @enqueueValueWithSize(this.@queue, "close", 0);
+ @putByIdDirectPrivate(this, "state", @streamClosing);
+ @enqueueValueWithSize(@getByIdDirectPrivate(this, "queue"), "close", 0);
@callOrScheduleWritableStreamAdvanceQueue(this);
- return this.@closedPromiseCapability.@promise;
+ return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
}
function write(chunk)
@@ -113,18 +115,19 @@
if (!@isWritableStream(this))
return @Promise.@reject(new @TypeError("The WritableStream.write method can only be used on instances of WritableStream"));
- if (this.@state === @streamClosed || this.@state === @streamClosing)
+ const state = @getByIdDirectPrivate(this, "state");
+ if (state === @streamClosed || state === @streamClosing)
return @Promise.@reject(new @TypeError("Cannot write on a WritableString that is closed or closing"));
- if (this.@state === @streamErrored)
+ if (state === @streamErrored)
return @Promise.@reject(this.@storedError);
- @assert(this.@state === @streamWritable || this.@state === @streamWaiting);
+ @assert(state === @streamWritable || state === @streamWaiting);
let chunkSize = 1;
- if (th...@strategy.size !== @undefined) {
+ if (@getByIdDirectPrivate(this, "strategy").size !== @undefined) {
try {
- chunkSize = th...@strategy.size.@call(@undefined, chunk);
+ chunkSize = @getByIdDirectPrivate(this, "strategy").size.@call(@undefined, chunk);
} catch(e) {
@errorWritableStream(this, e);
return @Promise.@reject(e);
@@ -133,7 +136,7 @@
const promiseCapability = @newPromiseCapability(@Promise);
try {
- @enqueueValueWithSize(this.@queue, { promiseCapability: promiseCapability, chunk: chunk }, chunkSize);
+ @enqueueValueWithSize(@getByIdDirectPrivate(this, "queue"), { promiseCapability: promiseCapability, chunk: chunk }, chunkSize);
} catch (e) {
@errorWritableStream(this, e);
return @Promise.@reject(e);
@@ -153,7 +156,7 @@
if (!@isWritableStream(this))
return @Promise.@reject(new @TypeError("The WritableStream.closed getter can only be used on instances of WritableStream"));
- return this.@closedPromiseCapability.@promise;
+ return @getByIdDirectPrivate(this, "closedPromiseCapability").@promise;
}
@getter
@@ -164,7 +167,7 @@
if (!@isWritableStream(this))
return @Promise.@reject(new @TypeError("The WritableStream.ready getter can only be used on instances of WritableStream"));
- return this.@readyPromiseCapability.@promise;
+ return @getByIdDirectPrivate(this, "readyPromiseCapability").@promise;
}
@getter
@@ -175,7 +178,7 @@
if (!@isWritableStream(this))
@throwTypeError("The WritableStream.state getter can only be used on instances of WritableStream");
- switch(this.@state) {
+ switch(@getByIdDirectPrivate(this, "state")) {
case @streamClosed:
return "closed";
case @streamClosing:
Modified: trunk/Source/WebCore/Modules/streams/WritableStreamInternals.js (230636 => 230637)
--- trunk/Source/WebCore/Modules/streams/WritableStreamInternals.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/Modules/streams/WritableStreamInternals.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -31,7 +31,7 @@
{
"use strict";
- return @isObject(stream) && !!stream.@underlyingSink;
+ return @isObject(stream) && !!@getByIdDirectPrivate(stream, "underlyingSink");
}
function syncWritableStreamStateWithQueue(stream)
@@ -38,19 +38,20 @@
{
"use strict";
- if (stream.@state === @streamClosing)
+ const state = @getByIdDirectPrivate(stream, "state");
+ if (state === @streamClosing)
return;
- @assert(stream.@state === @streamWritable || stream.@state === @streamWaiting);
+ @assert(state === @streamWritable || state === @streamWaiting);
- const shouldApplyBackpressure = stre...@queue.size > stream.@strategy.highWaterMark;
- if (shouldApplyBackpressure && stream.@state === @streamWritable) {
- stream.@state = @streamWaiting;
- stream.@readyPromiseCapability = @newPromiseCapability(@Promise);
+ const shouldApplyBackpressure = @getByIdDirectPrivate(stream, "queue").size > @getByIdDirectPrivate(stream, "strategy").highWaterMark;
+ if (shouldApplyBackpressure && state === @streamWritable) {
+ @putByIdDirectPrivate(stream, "state", @streamWaiting);
+ @putByIdDirectPrivate(stream, "readyPromiseCapability", @newPromiseCapability(@Promise));
}
- if (!shouldApplyBackpressure && stream.@state === @streamWaiting) {
- stream.@state = @streamWritable;
- stream.@readyPromiseCapability.@resolve.@call();
+ if (!shouldApplyBackpressure && state === @streamWaiting) {
+ @putByIdDirectPrivate(stream, "state", @streamWritable);
+ @getByIdDirectPrivate(stream, "readyPromiseCapability").@resolve.@call();
}
}
@@ -58,18 +59,19 @@
{
"use strict";
- if (stream.@state === @streamClosed || stream.@state === @streamErrored)
+ const state = @getByIdDirectPrivate(stream, "state");
+ if (state === @streamClosed || state === @streamErrored)
return;
- while (stream.@queue.content.length > 0) {
- const writeRecord = @dequeueValue(stream.@queue);
+ while (@getByIdDirectPrivate(stream, "queue").content.length > 0) {
+ const writeRecord = @dequeueValue(@getByIdDirectPrivate(stream, "queue"));
if (writeRecord !== "close")
writeRecord.promiseCapability.@reject.@call(@undefined, e);
}
- stream.@storedError = e;
- if (stream.@state === @streamWaiting)
- stream.@readyPromiseCapability.@resolve.@call();
- stream.@closedPromiseCapability.@reject.@call(@undefined, e);
- stream.@state = @streamErrored;
+ @putByIdDirectPrivate(stream, "storedError", e);
+ if (state === @streamWaiting)
+ @getByIdDirectPrivate(stream, "readyPromiseCapability").@resolve.@call();
+ @getByIdDirectPrivate(stream, "closedPromiseCapability").@reject.@call(@undefined, e);
+ @putByIdDirectPrivate(stream, "state", @streamErrored);
}
function callOrScheduleWritableStreamAdvanceQueue(stream)
@@ -76,8 +78,8 @@
{
"use strict";
- if (!stream.@started)
- stream.@startedPromise.@then(function() { @writableStreamAdvanceQueue(stream); });
+ if (!@getByIdDirectPrivate(stream, "started"))
+ @getByIdDirectPrivate(stream, "startedPromise").@then(function() { @writableStreamAdvanceQueue(stream); });
else
@writableStreamAdvanceQueue(stream);
}
@@ -86,26 +88,26 @@
{
"use strict";
- if (stream.@queue.content.length === 0 || stream.@writing)
+ if (@getByIdDirectPrivate(stream, "queue").content.length === 0 || @getByIdDirectPrivate(stream, "writing"))
return;
- const writeRecord = @peekQueueValue(stream.@queue);
+ const writeRecord = @peekQueueValue(@getByIdDirectPrivate(stream, "queue"));
if (writeRecord === "close") {
- @assert(stream.@state === @streamClosing);
- @dequeueValue(stream.@queue);
- @assert(stream.@queue.content.length === 0);
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamClosing);
+ @dequeueValue(@getByIdDirectPrivate(stream, "queue"));
+ @assert(@getByIdDirectPrivate(stream, "queue").content.length === 0);
@closeWritableStream(stream);
return;
}
- stream.@writing = true;
- @promiseInvokeOrNoop(stream.@underlyingSink, "write", [writeRecord.chunk]).@then(
+ @putByIdDirectPrivate(stream, "writing", true);
+ @promiseInvokeOrNoop(@getByIdDirectPrivate(stream, "underlyingSink"), "write", [writeRecord.chunk]).@then(
function() {
- if (stream.@state === @streamErrored)
+ if (@getByIdDirectPrivate(stream, "state") === @streamErrored)
return;
- stream.@writing = false;
+ @putByIdDirectPrivate(stream, "writing", false);
writeRecord.promiseCapability.@resolve.@call();
- @dequeueValue(stream.@queue);
+ @dequeueValue(@getByIdDirectPrivate(stream, "queue"));
@syncWritableStreamStateWithQueue(stream);
@writableStreamAdvanceQueue(stream);
},
@@ -119,14 +121,14 @@
{
"use strict";
- @assert(stream.@state === @streamClosing);
- @promiseInvokeOrNoop(stream.@underlyingSink, "close").@then(
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamClosing);
+ @promiseInvokeOrNoop(@getByIdDirectPrivate(stream, "underlyingSink"), "close").@then(
function() {
- if (stream.@state === @streamErrored)
+ if (@getByIdDirectPrivate(stream, "state") === @streamErrored)
return;
- @assert(stream.@state === @streamClosing);
- stream.@closedPromiseCapability.@resolve.@call();
- stream.@state = @streamClosed;
+ @assert(@getByIdDirectPrivate(stream, "state") === @streamClosing);
+ @getByIdDirectPrivate(stream, "closedPromiseCapability").@resolve.@call();
+ @putByIdDirectPrivate(stream, "state", @streamClosed);
},
function(r) {
@errorWritableStream(stream, r);
Modified: trunk/Source/WebCore/bindings/js/JSDOMBindingInternals.js (230636 => 230637)
--- trunk/Source/WebCore/bindings/js/JSDOMBindingInternals.js 2018-04-13 16:54:12 UTC (rev 230636)
+++ trunk/Source/WebCore/bindings/js/JSDOMBindingInternals.js 2018-04-13 17:01:40 UTC (rev 230637)
@@ -28,7 +28,7 @@
function mapLikeForEach(callback)
{
"use strict";
- this.@backingMap.forEach((value, key, map) => {
+ @getByIdDirectPrivate(this, "backingMap").forEach((value, key, map) => {
callback(value, key, this);
});
}
