Lines Matching refs:stream
5676 function AcquireWritableStreamDefaultWriter(stream) {
5677 return new WritableStreamDefaultWriter(stream);
5692 function IsWritableStreamLocked(stream) {
5693 …assert(IsWritableStream(stream) === true, 'IsWritableStreamLocked should only be used on known wri…
5695 if (stream._writer === undefined) {
5702 function WritableStreamAbort(stream, reason) {
5703 var state = stream._state;
5710 return Promise.reject(stream._storedError);
5715 if (stream._pendingAbortRequest !== undefined) {
5728 stream._pendingAbortRequest = {
5737 WritableStreamStartErroring(stream, error);
5743 function WritableStreamAddWriteRequest(stream) {
5744 assert(IsWritableStreamLocked(stream) === true);
5745 assert(stream._state === 'writable');
5752 stream._writeRequests.push(writeRequest);
5757 function WritableStreamDealWithRejection(stream, error) {
5758 var state = stream._state;
5761 WritableStreamStartErroring(stream, error);
5766 WritableStreamFinishErroring(stream);
5769 function WritableStreamStartErroring(stream, reason) {
5770 assert(stream._storedError === undefined, 'stream._storedError === undefined');
5771 assert(stream._state === 'writable', 'state must be writable');
5772 var controller = stream._writableStreamController;
5774 stream._state = 'erroring';
5775 stream._storedError = reason;
5776 var writer = stream._writer;
5782 … if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {
5783 WritableStreamFinishErroring(stream);
5787 function WritableStreamFinishErroring(stream) {
5788 assert(stream._state === 'erroring', 'stream._state === erroring');
5789 …assert(WritableStreamHasOperationMarkedInFlight(stream) === false, 'WritableStreamHasOperationMark…
5790 stream._state = 'errored';
5792 stream._writableStreamController.__errorSteps();
5794 var storedError = stream._storedError;
5796 for (var i = 0; i < stream._writeRequests.length; i++) {
5797 var writeRequest = stream._writeRequests[i];
5802 stream._writeRequests = [];
5804 if (stream._pendingAbortRequest === undefined) {
5805 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
5809 var abortRequest = stream._pendingAbortRequest;
5810 stream._pendingAbortRequest = undefined;
5815 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
5819 var promise = stream._writableStreamController.__abortSteps(abortRequest._reason);
5824 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
5828 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
5832 function WritableStreamFinishInFlightWrite(stream) {
5833 assert(stream._inFlightWriteRequest !== undefined);
5835 stream._inFlightWriteRequest._resolve(undefined);
5837 stream._inFlightWriteRequest = undefined;
5840 function WritableStreamFinishInFlightWriteWithError(stream, error) {
5841 assert(stream._inFlightWriteRequest !== undefined);
5843 stream._inFlightWriteRequest._reject(error);
5845 stream._inFlightWriteRequest = undefined;
5846 assert(stream._state === 'writable' || stream._state === 'erroring');
5847 WritableStreamDealWithRejection(stream, error);
5850 function WritableStreamFinishInFlightClose(stream) {
5851 assert(stream._inFlightCloseRequest !== undefined);
5853 stream._inFlightCloseRequest._resolve(undefined);
5855 stream._inFlightCloseRequest = undefined;
5856 var state = stream._state;
5860 stream._storedError = undefined;
5862 if (stream._pendingAbortRequest !== undefined) {
5863 stream._pendingAbortRequest._resolve();
5865 stream._pendingAbortRequest = undefined;
5869 stream._state = 'closed';
5870 var writer = stream._writer;
5876 assert(stream._pendingAbortRequest === undefined, 'stream._pendingAbortRequest === undefined');
5877 assert(stream._storedError === undefined, 'stream._storedError === undefined');
5880 function WritableStreamFinishInFlightCloseWithError(stream, error) {
5881 assert(stream._inFlightCloseRequest !== undefined);
5883 stream._inFlightCloseRequest._reject(error);
5885 stream._inFlightCloseRequest = undefined;
5886 assert(stream._state === 'writable' || stream._state === 'erroring');
5888 if (stream._pendingAbortRequest !== undefined) {
5889 stream._pendingAbortRequest._reject(error);
5891 stream._pendingAbortRequest = undefined;
5894 WritableStreamDealWithRejection(stream, error);
5897 function WritableStreamCloseQueuedOrInFlight(stream) {
5898 if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
5905 function WritableStreamHasOperationMarkedInFlight(stream) {
5906 if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
5913 function WritableStreamMarkCloseRequestInFlight(stream) {
5914 assert(stream._inFlightCloseRequest === undefined);
5915 assert(stream._closeRequest !== undefined);
5916 stream._inFlightCloseRequest = stream._closeRequest;
5917 stream._closeRequest = undefined;
5920 function WritableStreamMarkFirstWriteRequestInFlight(stream) {
5921 assert(stream._inFlightWriteRequest === undefined, 'there must be no pending write request');
5922 assert(stream._writeRequests.length !== 0, 'writeRequests must not be empty');
5923 stream._inFlightWriteRequest = stream._writeRequests.shift();
5926 function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
5927 assert(stream._state === 'errored', '_stream_.[[state]] is `"errored"`');
5929 if (stream._closeRequest !== undefined) {
5930 assert(stream._inFlightCloseRequest === undefined);
5932 stream._closeRequest._reject(stream._storedError);
5934 stream._closeRequest = undefined;
5937 var writer = stream._writer;
5940 defaultWriterClosedPromiseReject(writer, stream._storedError);
5946 function WritableStreamUpdateBackpressure(stream, backpressure) {
5947 assert(stream._state === 'writable');
5948 assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
5949 var writer = stream._writer;
5951 if (writer !== undefined && backpressure !== stream._backpressure) {
5960 stream._backpressure = backpressure;
5964 function WritableStreamDefaultWriter(stream) {
5967 if (IsWritableStream(stream) === false) {
5971 if (IsWritableStreamLocked(stream) === true) {
5975 this._ownerWritableStream = stream;
5976 stream._writer = this;
5977 var state = stream._state;
5980 … if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) {
5988 defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
5998 var storedError = stream._storedError;
6029 var stream = this._ownerWritableStream;
6031 if (stream === undefined) {
6035 if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
6048 var stream = this._ownerWritableStream;
6050 if (stream === undefined) {
6054 assert(stream._writer !== undefined);
6119 var stream = writer._ownerWritableStream;
6120 assert(stream !== undefined);
6121 return WritableStreamAbort(stream, reason);
6125 var stream = writer._ownerWritableStream;
6126 assert(stream !== undefined);
6127 var state = stream._state;
6134 assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
6140 stream._closeRequest = closeRequest;
6143 if (stream._backpressure === true && state === 'writable') {
6147 WritableStreamDefaultControllerClose(stream._writableStreamController);
6152 var stream = writer._ownerWritableStream;
6153 assert(stream !== undefined);
6154 var state = stream._state;
6156 if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
6161 return Promise.reject(stream._storedError);
6189 var stream = writer._ownerWritableStream;
6190 var state = stream._state;
6200 return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
6204 var stream = writer._ownerWritableStream;
6205 assert(stream !== undefined);
6206 assert(stream._writer === writer);
6210 stream._writer = undefined;
6215 var stream = writer._ownerWritableStream;
6216 assert(stream !== undefined);
6217 var controller = stream._writableStreamController;
6220 if (stream !== writer._ownerWritableStream) {
6224 var state = stream._state;
6227 return Promise.reject(stream._storedError);
6230 if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
6235 return Promise.reject(stream._storedError);
6239 var promise = WritableStreamAddWriteRequest(stream);
6245 function WritableStreamDefaultController(stream, underlyingSink, size, highWaterMark) {
6248 if (IsWritableStream(stream) === false) {
6252 if (stream._writableStreamController !== undefined) {
6256 this._controlledWritableStream = stream;
6266 WritableStreamUpdateBackpressure(stream, backpressure);
6300 var stream = this._controlledWritableStream;
6302 assert(stream._state === 'writable' || stream._state === 'erroring');
6306 assert(stream._state === 'writable' || stream._state === 'erroring');
6308 WritableStreamDealWithRejection(stream, r);
6352 var stream = controller._controlledWritableStream;
6354 if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {
6356 WritableStreamUpdateBackpressure(stream, backpressure);
6375 var stream = controller._controlledWritableStream;
6381 if (stream._inFlightWriteRequest !== undefined) {
6385 var state = stream._state;
6392 WritableStreamFinishErroring(stream);
6416 var stream = controller._controlledWritableStream;
6417 WritableStreamMarkCloseRequestInFlight(stream);
6422 WritableStreamFinishInFlightClose(stream);
6424 WritableStreamFinishInFlightCloseWithError(stream, reason);
6429 var stream = controller._controlledWritableStream;
6430 WritableStreamMarkFirstWriteRequestInFlight(stream);
6433 WritableStreamFinishInFlightWrite(stream);
6434 var state = stream._state;
6438 if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {
6440 WritableStreamUpdateBackpressure(stream, backpressure);
6445 WritableStreamFinishInFlightWriteWithError(stream, reason);
6455 var stream = controller._controlledWritableStream;
6456 assert(stream._state === 'writable');
6457 WritableStreamStartErroring(stream, error);
6886 function isOrBecomesErrored(stream, promise, action) {
6887 if (stream._state === 'errored') {
6888 action(stream._storedError);
6894 function isOrBecomesClosed(stream, promise, action) {
6895 if (stream._state === 'closed') {
6985 function AcquireReadableStreamBYOBReader(stream) {
6986 return new ReadableStreamBYOBReader(stream);
6989 function AcquireReadableStreamDefaultReader(stream) {
6990 return new ReadableStreamDefaultReader(stream);
7005 function IsReadableStreamDisturbed(stream) {
7006 …assert(IsReadableStream(stream) === true, 'IsReadableStreamDisturbed should only be used on known …
7007 return stream._disturbed;
7010 function IsReadableStreamLocked(stream) {
7011 …assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only be used on known rea…
7013 if (stream._reader === undefined) {
7020 function ReadableStreamTee(stream, cloneForBranch2) {
7021 assert(IsReadableStream(stream) === true);
7023 var reader = AcquireReadableStreamDefaultReader(stream);
7039 cancel1._stream = stream;
7042 cancel2._stream = stream;
7114 var stream = f._stream,
7121 var cancelResult = ReadableStreamCancel(stream, compositeReason);
7134 var stream = f._stream,
7141 var cancelResult = ReadableStreamCancel(stream, compositeReason);
7152 function ReadableStreamAddReadIntoRequest(stream) {
7153 assert(IsReadableStreamBYOBReader(stream._reader) === true);
7154 assert(stream._state === 'readable' || stream._state === 'closed');
7161 stream._reader._readIntoRequests.push(readIntoRequest);
7166 function ReadableStreamAddReadRequest(stream) {
7167 assert(IsReadableStreamDefaultReader(stream._reader) === true);
7168 assert(stream._state === 'readable');
7175 stream._reader._readRequests.push(readRequest);
7180 function ReadableStreamCancel(stream, reason) {
7181 stream._disturbed = true;
7183 if (stream._state === 'closed') {
7187 if (stream._state === 'errored') {
7188 return Promise.reject(stream._storedError);
7191 ReadableStreamClose(stream);
7193 var sourceCancelPromise = stream._readableStreamController.__cancelSteps(reason);
7200 function ReadableStreamClose(stream) {
7201 assert(stream._state === 'readable');
7202 stream._state = 'closed';
7203 var reader = stream._reader;
7223 function ReadableStreamError(stream, e) {
7224 assert(IsReadableStream(stream) === true, 'stream must be ReadableStream');
7225 assert(stream._state === 'readable', 'state must be readable');
7226 stream._state = 'errored';
7227 stream._storedError = e;
7228 var reader = stream._reader;
7259 function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
7260 var reader = stream._reader;
7268 function ReadableStreamFulfillReadRequest(stream, chunk, done) {
7269 var reader = stream._reader;
7277 function ReadableStreamGetNumReadIntoRequests(stream) {
7278 return stream._reader._readIntoRequests.length;
7281 function ReadableStreamGetNumReadRequests(stream) {
7282 return stream._reader._readRequests.length;
7285 function ReadableStreamHasBYOBReader(stream) {
7286 var reader = stream._reader;
7299 function ReadableStreamHasDefaultReader(stream) {
7300 var reader = stream._reader;
7314 function ReadableStreamDefaultReader(stream) {
7317 if (IsReadableStream(stream) === false) {
7321 if (IsReadableStreamLocked(stream) === true) {
7325 ReadableStreamReaderGenericInitialize(this, stream);
7387 function ReadableStreamBYOBReader(stream) {
7390 if (!IsReadableStream(stream)) {
7394 if (IsReadableByteStreamController(stream._readableStreamController) === false) {
7398 if (IsReadableStreamLocked(stream)) {
7402 ReadableStreamReaderGenericInitialize(this, stream);
7495 function ReadableStreamReaderGenericInitialize(reader, stream) {
7496 reader._ownerReadableStream = stream;
7497 stream._reader = reader;
7499 if (stream._state === 'readable') {
7501 } else if (stream._state === 'closed') {
7504 assert(stream._state === 'errored', 'state must be errored');
7505 defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
7512 var stream = reader._ownerReadableStream;
7513 assert(stream !== undefined);
7514 return ReadableStreamCancel(stream, reason);
7534 var stream = reader._ownerReadableStream;
7535 assert(stream !== undefined);
7536 stream._disturbed = true;
7538 if (stream._state === 'errored') {
7539 return Promise.reject(stream._storedError);
7542 return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
7546 var stream = reader._ownerReadableStream;
7547 assert(stream !== undefined);
7548 stream._disturbed = true;
7550 if (stream._state === 'closed') {
7554 if (stream._state === 'errored') {
7555 return Promise.reject(stream._storedError);
7558 assert(stream._state === 'readable');
7559 return stream._readableStreamController.__pullSteps();
7563 function ReadableStreamDefaultController(stream, underlyingSource, size, highWaterMark) {
7566 if (IsReadableStream(stream) === false) {
7570 if (stream._readableStreamController !== undefined) {
7574 this._controlledReadableStream = stream;
7643 var stream = this._controlledReadableStream;
7645 if (stream._state !== 'readable') {
7646 throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
7660 var stream = this._controlledReadableStream;
7666 ReadableStreamClose(stream);
7674 var pendingPromise = ReadableStreamAddReadRequest(stream);
7735 var stream = controller._controlledReadableStream;
7737 if (stream._state === 'closed' || stream._state === 'errored') {
7749 if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
7763 var stream = controller._controlledReadableStream;
7765 assert(stream._state === 'readable');
7769 ReadableStreamClose(stream);
7774 var stream = controller._controlledReadableStream;
7776 assert(stream._state === 'readable');
7778 if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
7779 ReadableStreamFulfillReadRequest(stream, chunk, false);
7807 var stream = controller._controlledReadableStream;
7808 assert(stream._state === 'readable');
7810 ReadableStreamError(stream, e);
7820 var stream = controller._controlledReadableStream;
7821 var state = stream._state;
7883 function ReadableByteStreamController(stream, underlyingByteSource, highWaterMark) {
7886 if (IsReadableStream(stream) === false) {
7890 if (stream._readableStreamController !== undefined) {
7894 this._controlledReadableStream = stream;
7922 if (stream._state === 'readable') {
7977 var stream = this._controlledReadableStream;
7979 if (stream._state !== 'readable') {
7980 throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
7999 var stream = this._controlledReadableStream;
8000 assert(ReadableStreamHasDefaultReader(stream) === true);
8003 assert(ReadableStreamGetNumReadRequests(stream) === 0);
8044 var promise = ReadableStreamAddReadRequest(stream);
8136 function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
8137 assert(stream._state !== 'errored', 'state must not be errored');
8140 if (stream._state === 'closed') {
8148 ReadableStreamFulfillReadRequest(stream, filledView, done);
8151 ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
8260 var stream = controller._controlledReadableStream;
8283 return ReadableStreamAddReadIntoRequest(stream);
8286 if (stream._state === 'closed') {
8309 var promise = ReadableStreamAddReadIntoRequest(stream);
8317 var stream = controller._controlledReadableStream;
8319 if (ReadableStreamHasBYOBReader(stream) === true) {
8320 while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
8322 ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
8355 var stream = controller._controlledReadableStream;
8357 if (stream._state === 'closed') {
8364 assert(stream._state === 'readable');
8377 var stream = controller._controlledReadableStream;
8379 if (stream._state !== 'readable') {
8391 …if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > …
8395 …if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) >…
8407 var stream = controller._controlledReadableStream;
8409 assert(stream._state === 'readable');
8426 ReadableStreamClose(stream);
8430 var stream = controller._controlledReadableStream;
8432 assert(stream._state === 'readable');
8438 if (ReadableStreamHasDefaultReader(stream) === true) {
8439 if (ReadableStreamGetNumReadRequests(stream) === 0) {
8444 ReadableStreamFulfillReadRequest(stream, transferredView, false);
8446 } else if (ReadableStreamHasBYOBReader(stream) === true) {
8450 assert(IsReadableStreamLocked(stream) === false, 'stream must not be locked');
8456 var stream = controller._controlledReadableStream;
8457 assert(stream._state === 'readable');
8460 ReadableStreamError(stream, e);
8464 var stream = controller._controlledReadableStream;
8465 var state = stream._state;
16775 if (data.stream) {
16902 stream: 'pull',
16917 stream: 'cancel',
16938 var stream = _ref.stream,
16947 stream: stream,
16973 stream: 'enqueue',
16985 stream: 'close'
16996 stream: 'error',
17012 stream: 'start_complete',
17017 stream: 'start_complete',
17031 var stream = _ref2.stream,
17038 stream: stream,
17053 switch (data.stream) {
17065 stream: 'pull_complete',
17078 stream: 'pull_complete',
17083 stream: 'pull_complete',
17129 stream: 'cancel_complete',
17134 stream: 'cancel_complete',
18031 function PDFDataTransportStreamReader(stream, queuedChunks) {
18036 this._stream = stream;
18067 stream._fullRequestReader = this;
18201 function PDFDataTransportStreamRangeReader(stream, begin, end) {
18204 this._stream = stream;
22709 function BaseFullReader(stream) {
22712 this._url = stream.url;
22716 var source = stream.source;
22886 function BaseRangeReader(stream) {
22889 this._url = stream.url;
22896 var source = stream.source;
23041 function PDFNodeStreamFullReader(stream) {
23046 …s3 = _possibleConstructorReturn(this, _getPrototypeOf(PDFNodeStreamFullReader).call(this, stream));
23068 isHttp: stream.isHttp,
23083 …_this3._request = http.request(createRequestOptions(_this3._url, stream.httpHeaders), handleRespon…
23085 …_this3._request = https.request(createRequestOptions(_this3._url, stream.httpHeaders), handleRespo…
23107 function PDFNodeStreamRangeReader(stream, start, end) {
23112 …4 = _possibleConstructorReturn(this, _getPrototypeOf(PDFNodeStreamRangeReader).call(this, stream));
23115 for (var property in stream.httpHeaders) {
23116 var value = stream.httpHeaders[property];
23162 function PDFNodeStreamFsFullReader(stream) {
23167 … = _possibleConstructorReturn(this, _getPrototypeOf(PDFNodeStreamFsFullReader).call(this, stream));
23204 function PDFNodeStreamFsRangeReader(stream, start, end) {
23209 …= _possibleConstructorReturn(this, _getPrototypeOf(PDFNodeStreamFsRangeReader).call(this, stream));
24313 function PDFFetchStreamReader(stream) {
24318 this._stream = stream;
24322 var source = stream.source;
24493 function PDFFetchStreamRangeReader(stream, begin, end) {
24498 this._stream = stream;
24501 var source = stream.source;