Lines Matching refs:controller
6458 start: function start(controller) {
6459 controller.close();
6941 var controller = stream._writableStreamController;
6942 assert(controller !== undefined, 'controller must not be undefined');
6951 … if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {
7386 var controller = stream._writableStreamController;
7387 var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
7409 WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
7485 function WritableStreamDefaultControllerClose(controller) {
7486 EnqueueValueWithSize(controller, 'close', 0);
7487 WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
7490 function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
7491 var strategySize = controller._strategySize;
7500 WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
7505 function WritableStreamDefaultControllerGetDesiredSize(controller) {
7506 return controller._strategyHWM - controller._queueTotalSize;
7509 function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
7515 EnqueueValueWithSize(controller, writeRecord, chunkSize);
7517 WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
7521 var stream = controller._controlledWritableStream;
7524 var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
7528 WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
7543 function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
7544 var stream = controller._controlledWritableStream;
7546 if (controller._started === false) {
7565 if (controller._queue.length === 0) {
7569 var writeRecord = PeekQueueValue(controller);
7572 WritableStreamDefaultControllerProcessClose(controller);
7574 WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);
7578 function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
7579 if (controller._controlledWritableStream._state === 'writable') {
7580 WritableStreamDefaultControllerError(controller, error);
7584 function WritableStreamDefaultControllerProcessClose(controller) {
7585 var stream = controller._controlledWritableStream;
7587 DequeueValue(controller);
7588 …assert(controller._queue.length === 0, 'queue must be empty once the final write record is dequeue…
7589 var sinkClosePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'close', []);
7597 function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
7598 var stream = controller._controlledWritableStream;
7600 …var sinkWritePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'write', [chunk, controller…
7605 DequeueValue(controller);
7608 var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
7612 WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
7618 function WritableStreamDefaultControllerGetBackpressure(controller) {
7619 var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
7623 function WritableStreamDefaultControllerError(controller, error) {
7624 var stream = controller._controlledWritableStream;
8755 var controller = this;
8758 controller._started = true;
8759 assert(controller._pulling === false);
8760 assert(controller._pullAgain === false);
8761 ReadableStreamDefaultControllerCallPullIfNeeded(controller);
8763 ReadableStreamDefaultControllerErrorIfNeeded(controller, r);
8873 function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
8874 var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
8880 if (controller._pulling === true) {
8881 controller._pullAgain = true;
8885 assert(controller._pullAgain === false);
8886 controller._pulling = true;
8887 var pullPromise = PromiseInvokeOrNoop(controller._underlyingSource, 'pull', [controller]);
8889 controller._pulling = false;
8891 if (controller._pullAgain === true) {
8892 controller._pullAgain = false;
8893 return ReadableStreamDefaultControllerCallPullIfNeeded(controller);
8898 ReadableStreamDefaultControllerErrorIfNeeded(controller, e);
8903 function ReadableStreamDefaultControllerShouldCallPull(controller) {
8904 var stream = controller._controlledReadableStream;
8910 if (controller._closeRequested === true) {
8914 if (controller._started === false) {
8922 var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
8931 function ReadableStreamDefaultControllerClose(controller) {
8932 var stream = controller._controlledReadableStream;
8933 assert(controller._closeRequested === false);
8935 controller._closeRequested = true;
8937 if (controller._queue.length === 0) {
8942 function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
8943 var stream = controller._controlledReadableStream;
8944 assert(controller._closeRequested === false);
8952 if (controller._strategySize !== undefined) {
8953 var strategySize = controller._strategySize;
8958 ReadableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
8964 EnqueueValueWithSize(controller, chunk, chunkSize);
8966 ReadableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
8971 ReadableStreamDefaultControllerCallPullIfNeeded(controller);
8975 function ReadableStreamDefaultControllerError(controller, e) {
8976 var stream = controller._controlledReadableStream;
8978 ResetQueue(controller);
8982 function ReadableStreamDefaultControllerErrorIfNeeded(controller, e) {
8983 if (controller._controlledReadableStream._state === 'readable') {
8984 ReadableStreamDefaultControllerError(controller, e);
8988 function ReadableStreamDefaultControllerGetDesiredSize(controller) {
8989 var stream = controller._controlledReadableStream;
9000 return controller._strategyHWM - controller._queueTotalSize;
9004 function ReadableStreamBYOBRequest(controller, view) {
9007 this._associatedReadableByteStreamController = controller;
9083 var controller = this;
9086 controller._started = true;
9087 assert(controller._pulling === false);
9088 assert(controller._pullAgain === false);
9089 ReadableByteStreamControllerCallPullIfNeeded(controller);
9092 ReadableByteStreamControllerError(controller, r);
9270 function ReadableByteStreamControllerCallPullIfNeeded(controller) {
9271 var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
9277 if (controller._pulling === true) {
9278 controller._pullAgain = true;
9282 assert(controller._pullAgain === false);
9283 controller._pulling = true;
9284 var pullPromise = PromiseInvokeOrNoop(controller._underlyingByteSource, 'pull', [controller]);
9286 controller._pulling = false;
9288 if (controller._pullAgain === true) {
9289 controller._pullAgain = false;
9290 ReadableByteStreamControllerCallPullIfNeeded(controller);
9293 if (controller._controlledReadableStream._state === 'readable') {
9294 ReadableByteStreamControllerError(controller, e);
9300 function ReadableByteStreamControllerClearPendingPullIntos(controller) {
9301 ReadableByteStreamControllerInvalidateBYOBRequest(controller);
9302 controller._pendingPullIntos = [];
9332 …function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLengt…
9333 controller._queue.push({
9339 controller._queueTotalSize += byteLength;
9342 …function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescripto…
9345 …var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullInto…
9356 var queue = controller._queue;
9371 controller._queueTotalSize -= bytesToCopy;
9372 …ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor…
9377 assert(controller._queueTotalSize === 0, 'queue must be empty');
9385 …function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescript…
9386 …assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos[0] === pullIntoDe…
9387 ReadableByteStreamControllerInvalidateBYOBRequest(controller);
9391 function ReadableByteStreamControllerHandleQueueDrain(controller) {
9392 assert(controller._controlledReadableStream._state === 'readable');
9394 if (controller._queueTotalSize === 0 && controller._closeRequested === true) {
9395 ReadableStreamClose(controller._controlledReadableStream);
9397 ReadableByteStreamControllerCallPullIfNeeded(controller);
9401 function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
9402 if (controller._byobRequest === undefined) {
9406 controller._byobRequest._associatedReadableByteStreamController = undefined;
9407 controller._byobRequest._view = undefined;
9408 controller._byobRequest = undefined;
9411 function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
9412 assert(controller._closeRequested === false);
9414 while (controller._pendingPullIntos.length > 0) {
9415 if (controller._queueTotalSize === 0) {
9419 var pullIntoDescriptor = controller._pendingPullIntos[0];
9421 …if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) ==…
9422 ReadableByteStreamControllerShiftPendingPullInto(controller);
9423 …ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullInt…
9428 function ReadableByteStreamControllerPullInto(controller, view) {
9429 var stream = controller._controlledReadableStream;
9447 if (controller._pendingPullIntos.length > 0) {
9450 controller._pendingPullIntos.push(pullIntoDescriptor);
9460 if (controller._queueTotalSize > 0) {
9461 …if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) ==…
9463 ReadableByteStreamControllerHandleQueueDrain(controller);
9467 if (controller._closeRequested === true) {
9469 ReadableByteStreamControllerError(controller, e);
9476 controller._pendingPullIntos.push(pullIntoDescriptor);
9479 ReadableByteStreamControllerCallPullIfNeeded(controller);
9483 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
9486 var stream = controller._controlledReadableStream;
9490 var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
9496 …function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDesc…
9501 …ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescripto…
9507 ReadableByteStreamControllerShiftPendingPullInto(controller);
9513 … ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
9518 …ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullInt…
9519 ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
9522 function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
9523 var firstDescriptor = controller._pendingPullIntos[0];
9524 var stream = controller._controlledReadableStream;
9531 ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
9534 ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
9538 function ReadableByteStreamControllerShiftPendingPullInto(controller) {
9539 var descriptor = controller._pendingPullIntos.shift();
9541 ReadableByteStreamControllerInvalidateBYOBRequest(controller);
9545 function ReadableByteStreamControllerShouldCallPull(controller) {
9546 var stream = controller._controlledReadableStream;
9552 if (controller._closeRequested === true) {
9556 if (controller._started === false) {
9568 if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) {
9575 function ReadableByteStreamControllerClose(controller) {
9576 var stream = controller._controlledReadableStream;
9577 assert(controller._closeRequested === false);
9580 if (controller._queueTotalSize > 0) {
9581 controller._closeRequested = true;
9585 if (controller._pendingPullIntos.length > 0) {
9586 var firstPendingPullInto = controller._pendingPullIntos[0];
9590 ReadableByteStreamControllerError(controller, e);
9598 function ReadableByteStreamControllerEnqueue(controller, chunk) {
9599 var stream = controller._controlledReadableStream;
9600 assert(controller._closeRequested === false);
9609 …ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLen…
9611 assert(controller._queue.length === 0);
9616 …ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLen…
9617 ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
9620 …ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLen…
9624 function ReadableByteStreamControllerError(controller, e) {
9625 var stream = controller._controlledReadableStream;
9627 ReadableByteStreamControllerClearPendingPullIntos(controller);
9628 ResetQueue(controller);
9632 function ReadableByteStreamControllerGetDesiredSize(controller) {
9633 var stream = controller._controlledReadableStream;
9644 return controller._strategyHWM - controller._queueTotalSize;
9647 function ReadableByteStreamControllerRespond(controller, bytesWritten) {
9654 assert(controller._pendingPullIntos.length > 0);
9655 ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
9658 function ReadableByteStreamControllerRespondWithNewView(controller, view) {
9659 assert(controller._pendingPullIntos.length > 0);
9660 var firstDescriptor = controller._pendingPullIntos[0];
9671 ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
9845 var controller = transformStream._readableController;
9848 ReadableStreamDefaultControllerEnqueue(controller, chunk);
9855 var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
9945 var controller = transformStream._transformStreamController;
9946 …mFallback(transformer, 'transform', [chunk, controller], TransformStreamDefaultTransform, [chunk, …
55650 start: function start(controller) {
55653 controller: controller,
55664 desiredSize: controller.desiredSize
55669 pull: function pull(controller) {
55678 desiredSize: controller.desiredSize
55868 this.streamControllers[data.streamId].controller.enqueue(data.chunk);
55881 this.streamControllers[data.streamId].controller.close();
55887 this.streamControllers[data.streamId].controller.error(wrapReason(data.reason));