Switch to owning

Author: youennf

reference-implementation/lib/ReadableStream-impl.js

@@ -29,7 +29,7 @@ exports.implementation = class ReadableStreamImpl {
         this, underlyingSource, underlyingSourceDict, highWaterMark
       );
     } else {
-      assert(!('type' in underlyingSourceDict) || underlyingSourceDict.type === 'transfer');
+      assert(!('type' in underlyingSourceDict) || underlyingSourceDict.type === 'owning');
       const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
       const highWaterMark = ExtractHighWaterMark(strategy, 1);
       aos.SetUpReadableStreamDefaultControllerFromUnderlyingSource(

reference-implementation/lib/ReadableStreamDefaultController-impl.js

@@ -19,12 +19,12 @@ exports.implementation = class ReadableStreamDefaultControllerImpl {
 
   enqueue(chunk, optionsOrTransfer) {
     const hasTransfer = optionsOrTransfer && !Array.isArray(optionsOrTransfer);
-    const transfer = hasTransfer ? optionsOrTransfer.transfer : optionsOrTransfer;
+    const transferList = hasTransfer ? optionsOrTransfer.transfer : optionsOrTransfer;
     if (aos.ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
       throw new TypeError('The stream is not in a state that permits enqueue');
     }
 
-    return aos.ReadableStreamDefaultControllerEnqueue(this, chunk, transfer);
+    return aos.ReadableStreamDefaultControllerEnqueue(this, chunk, transferList);
   }
 
   error(e) {

reference-implementation/lib/ReadableStreamDefaultController.webidl

@@ -7,7 +7,6 @@ interface ReadableStreamDefaultController {
   readonly attribute unrestricted double? desiredSize;
 
   undefined close();
-  undefined enqueue(any chunk, sequence<object> transfer);
   undefined enqueue(optional any chunk, optional StructuredSerializeOptions options = { });
   undefined error(optional any e);
 };

reference-implementation/lib/UnderlyingSource.webidl

@@ -12,4 +12,4 @@ callback UnderlyingSourceStartCallback = any (ReadableStreamController controlle
 callback UnderlyingSourcePullCallback = Promise<undefined> (ReadableStreamController controller);
 callback UnderlyingSourceCancelCallback = Promise<undefined> (optional any reason);
 
-enum ReadableStreamType { "bytes", "transfer" };
+enum ReadableStreamType { "bytes", "owning" };

reference-implementation/lib/abstract-ops/miscellaneous.js

@@ -21,10 +21,12 @@ exports.CloneAsUint8Array = O => {
   return new Uint8Array(buffer);
 };
 
-exports.StructuredTransferOrClone = (value, transfer) => {
-  // FIXME: We should check whether value is an array buffer or is transferable and update transfer accordingly.
-  if (self.structuredClone)
-    return structuredClone(value, transfer);
+exports.StructuredTransferOrClone = (value, transferList) => {
+console.log(globalThis);
+console.log(globalThis.structuredClone);
+
+  if (globalThis.structuredClone)
+    return globalThis.structuredClone(value, transferList);
 
   return JSON.parse(JSON.stringify(value));
 };

reference-implementation/lib/abstract-ops/queue-with-sizes.js

@@ -15,7 +15,7 @@ exports.DequeueValue = container => {
   return pair.value;
 };
 
-exports.EnqueueValueWithSize = (container, value, size, transfer) => {
+exports.EnqueueValueWithSize = (container, value, size, transferList) => {
   assert('_queue' in container && '_queueTotalSize' in container);
 
   if (!IsNonNegativeNumber(size)) {
@@ -24,8 +24,8 @@ exports.EnqueueValueWithSize = (container, value, size, transfer) => {
   if (size === Infinity) {
     throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
   }
-  if (container.isTransferring) {
-    value = StructuredTransferOrClone(value, transfer);
+  if (container.isOwning) {
+    value = StructuredTransferOrClone(value, transferList);
   }
   container._queue.push({ value, size });
   container._queueTotalSize += size;
@@ -42,7 +42,7 @@ exports.PeekQueueValue = container => {
 exports.ResetQueue = container => {
   assert('_queue' in container && '_queueTotalSize' in container);
 
-  if (container.isTransferring) {
+  if (container.isOwning) {
     while (container._queue.length > 0) {
       const value = exports.DequeueValue(container);
       if (typeof value.close === 'function') {

reference-implementation/lib/abstract-ops/readable-streams.js

@@ -340,7 +340,7 @@ function ReadableStreamTee(stream, cloneForBranch2) {
   if (ReadableByteStreamController.isImpl(stream._controller)) {
     return ReadableByteStreamTee(stream);
   }
-  return ReadableStreamDefaultTee(stream, stream._controller.isTransferring ? true : cloneForBranch2);
+  return ReadableStreamDefaultTee(stream, stream._controller.isOwning ? true : cloneForBranch2);
 }
 
 function ReadableStreamDefaultTee(stream, cloneForBranch2) {
@@ -1074,17 +1074,17 @@ function ReadableStreamDefaultControllerClose(controller) {
   }
 }
 
-function ReadableStreamDefaultControllerEnqueue(controller, chunk, transfer) {
+function ReadableStreamDefaultControllerEnqueue(controller, chunk, transferList) {
   if (ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) === false) {
     return;
   }
 
   const stream = controller._stream;
 
   if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
-    if (controller.isTransferring) {
+    if (controller.isOwning) {
       try {
-        chunk = StructuredTransferOrClone(chunk, transfer);
+        chunk = StructuredTransferOrClone(chunk, transferList);
       } catch (chunkCloneError) {
         ReadableStreamDefaultControllerError(controller, chunkCloneError);
         throw chunkCloneError;
@@ -1101,7 +1101,7 @@ function ReadableStreamDefaultControllerEnqueue(controller, chunk, transfer) {
     }
 
     try {
-      EnqueueValueWithSize(controller, chunk, chunkSize, transfer);
+      EnqueueValueWithSize(controller, chunk, chunkSize, transferList);
     } catch (enqueueE) {
       ReadableStreamDefaultControllerError(controller, enqueueE);
       throw enqueueE;
@@ -1156,7 +1156,7 @@ function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
 }
 
 function SetUpReadableStreamDefaultController(
-  stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm, isTransferring) {
+  stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm, isOwning) {
   assert(stream._controller === undefined);
 
   controller._stream = stream;
@@ -1177,7 +1177,7 @@ function SetUpReadableStreamDefaultController(
   controller._pullAlgorithm = pullAlgorithm;
   controller._cancelAlgorithm = cancelAlgorithm;
 
-  controller.isTransferring = isTransferring;
+  controller.isOwning= isOwning;
 
   stream._controller = controller;
 
@@ -1205,7 +1205,7 @@ function SetUpReadableStreamDefaultControllerFromUnderlyingSource(
   let startAlgorithm = () => undefined;
   let pullAlgorithm = () => promiseResolvedWith(undefined);
   let cancelAlgorithm = () => promiseResolvedWith(undefined);
-  const isTransferring = underlyingSourceDict.type === 'transfer';
+  const isOwning = underlyingSourceDict.type === 'owning';
   if ('start' in underlyingSourceDict) {
     startAlgorithm = () => underlyingSourceDict.start.call(underlyingSource, controller);
   }
@@ -1218,7 +1218,7 @@ function SetUpReadableStreamDefaultControllerFromUnderlyingSource(
 
   SetUpReadableStreamDefaultController(
     stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm,
-    isTransferring);
+    isOwning);
 }
 
 // Byte stream controllers