Error the stream if we cannot transfer the chunk.

Add a transferList optional parameter to enqueue.

Author: youennf

index.bs

@@ -1470,7 +1470,7 @@ interface ReadableStreamDefaultController {
   readonly attribute unrestricted double? desiredSize;
 
   undefined close();
-  undefined enqueue(optional any chunk);
+  undefined enqueue(optional any chunk, optional sequence<object> transfer = []);
   undefined error(optional any e);
 };
 </xmp>
@@ -1581,11 +1581,11 @@ the following table:
 
 <div algorithm>
  The <dfn id="rs-default-controller-enqueue" method
- for="ReadableStreamDefaultController">enqueue(|chunk|)</dfn> method steps are:
+ for="ReadableStreamDefaultController">enqueue(|chunk|, |transferList|)</dfn> method steps are:
 
  1. If ! [$ReadableStreamDefaultControllerCanCloseOrEnqueue$]([=this=]) is false, throw a
     {{TypeError}} exception.
- 1. Perform ? [$ReadableStreamDefaultControllerEnqueue$]([=this=], |chunk|).
+ 1. Perform ? [$ReadableStreamDefaultControllerEnqueue$]([=this=], |chunk|, |transferList|).
 </div>
 
 <div algorithm>
@@ -2301,10 +2301,10 @@ create them does not matter.
       1. Otherwise, set |chunk2| to |cloneResult|.\[[Value]].
      1. If |canceled1| is false, perform !
         [$ReadableStreamDefaultControllerEnqueue$](|branch1|.[=ReadableStream/[[controller]]=],
-        |chunk1|).
+        |chunk1|, undefined).
      1. If |canceled2| is false, perform !
         [$ReadableStreamDefaultControllerEnqueue$](|branch2|.[=ReadableStream/[[controller]]=],
-        |chunk2|).
+        |chunk2|, undefined).
      1. Set |reading| to false.
      1. If |readAgain| is true, perform |pullAlgorithm|.
 
@@ -2964,16 +2964,18 @@ The following abstract operations support the implementation of the
 <div algorithm>
  <dfn abstract-op lt="ReadableStreamDefaultControllerEnqueue"
  id="readable-stream-default-controller-enqueue">ReadableStreamDefaultControllerEnqueue(|controller|,
- |chunk|)</dfn> performs the following steps:
+ |chunk|, |transferList|)</dfn> performs the following steps:
 
  1. If ! [$ReadableStreamDefaultControllerCanCloseOrEnqueue$](|controller|) is false, return.
  1. Let |stream| be |controller|.[=ReadableStreamDefaultController/[[stream]]=].
  1. If ! [$IsReadableStreamLocked$](|stream|) is true and !
     [$ReadableStreamGetNumReadRequests$](|stream|) > 0, perform the following steps:
     1. Let |internalChunk| be |chunk|.
     1. If |controller|.[=ReadableStreamDefaultController/[[isTransferring]]=] is true, perform the following steps:
-       1. Set |internalChunk| to [$StructuredTransferOrSerialize$](|chunk|).
-       1. If |internalChunk| is an abrupt completion, return.
+       1. Set |internalChunk| to [$StructuredTransferOrClone$](|chunk|, |transferList|).
+       1. If |internalChunk| is an abrupt completion,
+          1. Perform ! [$ReadableStreamDefaultControllerError$](|controller|, |internalChunk|.\[[Value]]).
+          1. Return |internalChunk|.
     1. ![$ReadableStreamFulfillReadRequest$](|stream|, |internalChunk|, false).
  1. Otherwise,
   1. Let |result| be the result of performing
@@ -2983,7 +2985,7 @@ The following abstract operations support the implementation of the
    1. Perform ! [$ReadableStreamDefaultControllerError$](|controller|, |result|.\[[Value]]).
    1. Return |result|.
   1. Let |chunkSize| be |result|.\[[Value]].
-  1. Let |enqueueResult| be [$EnqueueValueWithSize$](|controller|, |chunk|, |chunkSize|).
+  1. Let |enqueueResult| be [$EnqueueValueWithSize$](|controller|, |chunk|, |chunkSize|, |transferList|).
   1. If |enqueueResult| is an abrupt completion,
    1. Perform ! [$ReadableStreamDefaultControllerError$](|controller|, |enqueueResult|.\[[Value]]).
    1. Return |enqueueResult|.
@@ -5207,7 +5209,7 @@ The following abstract operations support the implementation of the
  id="writable-stream-default-controller-close">WritableStreamDefaultControllerClose(|controller|)</dfn>
  performs the following steps:
 
- 1. Perform ! [$EnqueueValueWithSize$](|controller|, [=close sentinel=], 0).
+ 1. Perform ! [$EnqueueValueWithSize$](|controller|, [=close sentinel=], 0, undefined).
  1. Perform ! [$WritableStreamDefaultControllerAdvanceQueueIfNeeded$](|controller|).
 </div>
 
@@ -5311,7 +5313,7 @@ The following abstract operations support the implementation of the
  id="writable-stream-default-controller-write">WritableStreamDefaultControllerWrite(|controller|,
  |chunk|, |chunkSize|)</dfn> performs the following steps:
 
- 1. Let |enqueueResult| be [$EnqueueValueWithSize$](|controller|, |chunk|, |chunkSize|).
+ 1. Let |enqueueResult| be [$EnqueueValueWithSize$](|controller|, |chunk|, |chunkSize|, undefined).
  1. If |enqueueResult| is an abrupt completion,
   1. Perform ! [$WritableStreamDefaultControllerErrorIfNeeded$](|controller|,
      |enqueueResult|.\[[Value]]).
@@ -5905,7 +5907,7 @@ The following abstract operations support the implementaiton of the
  1. If ! [$ReadableStreamDefaultControllerCanCloseOrEnqueue$](|readableController|) is false, throw
     a {{TypeError}} exception.
  1. Let |enqueueResult| be [$ReadableStreamDefaultControllerEnqueue$](|readableController|,
-    |chunk|).
+    |chunk|, undefined).
  1. If |enqueueResult| is an abrupt completion,
    1. Perform ! [$TransformStreamErrorWritableAndUnblockWrite$](|stream|,
       |enqueueResult|.\[[Value]]).
@@ -6383,15 +6385,15 @@ for="value-with-size">value</dfn> and <dfn for="value-with-size">size</dfn>.
 
 <div algorithm>
  <dfn abstract-op lt="EnqueueValueWithSize"
- id="enqueue-value-with-size">EnqueueValueWithSize(|container|, |value|, |size|)</dfn> performs the
+ id="enqueue-value-with-size">EnqueueValueWithSize(|container|, |value|, |size|, |transferList|)</dfn> performs the
  following steps:
 
  1. Assert: |container| has \[[queue]] and \[[queueTotalSize]] internal slots.
  1. If ! [$IsNonNegativeNumber$](|size|) is false, throw a {{RangeError}} exception.
  1. If |size| is +∞, throw a {{RangeError}} exception.
  1. Let |enqueuedValue| be |value|.
  1. If |container|.\[[isTransferring]] is true, perform the following steps:
-    1. Set |enqueuedValue| to [$StructuredTransferOrSerialize$](|value|).
+    1. Set |enqueuedValue| to [$StructuredTransferOrClone$](|value|, |transferList|).
     1. If |enqueuedValue| is an abrupt completion, return.
  1. [=list/Append=] a new [=value-with-size=] with [=value-with-size/value=] |enqueuedValue| and
     [=value-with-size/size=] |size| to |container|.\[[queue]].
@@ -6476,7 +6478,7 @@ abstract operations are used to implement these "cross-realm transforms".
   1. Let |value| be ! [$Get$](|data|, "`value`").
   1. Assert: [$Type$](|type|) is String.
   1. If |type| is "`chunk`",
-   1. Perform ! [$ReadableStreamDefaultControllerEnqueue$](|controller|, |value|).
+   1. Perform ! [$ReadableStreamDefaultControllerEnqueue$](|controller|, |value|, undefined).
   1. Otherwise, if |type| is "`close`",
     1. Perform ! [$ReadableStreamDefaultControllerClose$](|controller|).
     1. Disentangle |port|.
@@ -6626,15 +6628,13 @@ The following abstract operations are a grab-bag of utilities.
 </div>
 
 <div algorithm>
- <dfn abstract-op lt="StructuredTransferOrSerialize">StructuredTransferOrSerialize(|value|)</dfn>
+ <dfn abstract-op lt="StructuredTransferOrClone">StructuredTransferOrClone(|value|, |transferList|)</dfn>
     performs the following steps:
- 1. If |value| is [=transferable objects|transferable=], perform the following steps:
-    // FIXME: We should probably handle other transferable types like ArrayBuffers.
-    1. Let |serialized| be ! [$StructuredSerializeWithTransfer$](|value|, « |value| »).
-    1. Let |deserialized| be ! [$StructuredDeserializeWithTransfer$](|serialized|,
-       [=the current Realm=]).
-    1. return |deserialized|.\[[Deserialized]].
- 1. Return [$StructuredClone$](|value|).
+ 1. If |value| has either an \[[ArrayBufferData]] internal slot or a \[[Detached]] internal slot,  perform the following steps:
+    1. If |transferList| is undefined or [=list/is empty|is an empty list=], set |transferList| to « |value| ».
+ 1. Let |serialized| be ! [$StructuredSerializeWithTransfer$](|value|, |transferList|).
+ 1. Let |deserialized| be ! [$StructuredDeserializeWithTransfer$](|serialized|, [=the current Realm=]).
+ 1. return |deserialized|.\[[Deserialized]].
 </div>
 
 <h2 id="other-specs">Using streams in other specifications</h2>
@@ -6768,13 +6768,13 @@ mark=] is greater than zero.
 </div>
 
 <div algorithm>
- To <dfn export for="ReadableStream">enqueue</dfn> the JavaScript value |chunk| into a
- {{ReadableStream}} |stream|:
+ To <dfn export for="ReadableStream">enqueue</dfn> the JavaScript value |chunk|
+ with an optional |transferList| into a {{ReadableStream}} |stream|:
 
  1. If |stream|.[=ReadableStream/[[controller]]=] [=implements=]
     {{ReadableStreamDefaultController}},
   1. Perform ! [$ReadableStreamDefaultControllerEnqueue$](|stream|.[=ReadableStream/[[controller]]=],
-     |chunk|).
+     |chunk|, |transferList|).
  1. Otherwise,
   1. Assert: |stream|.[=ReadableStream/[[controller]]=] [=implements=]
      {{ReadableByteStreamController}}.