switch to owning

Author: youennf

index.bs

@@ -572,7 +572,7 @@ 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" };
 </xmp>
 
 <dl>
@@ -652,7 +652,7 @@ enum ReadableStreamType { "bytes", "transfer" };
   controller interface, see [[#example-rbs-push]].
 
   <p>Can be set to "<dfn enum-value for="ReadableStreamType">transfer</dfn>" to signal that the
-  constructed {{ReadableStream}} will transfer or serialize chunks before enqueuing them.
+  constructed {{ReadableStream}} will own chunks (via transfer or serialization) before enqueuing them.
   This ensures that enqueued chunks are not mutable by the source.
   Transferred or serialized chunks may have <dfn>closing steps</dfn> which are executed if
   enqueued chunks are dequeued without being provided to the application, for instance when
@@ -810,7 +810,7 @@ option. If {{UnderlyingSource/type}} is set to undefined (including via omission
      |underlyingSource|, |underlyingSourceDict|, |highWaterMark|).
  1. Otherwise,
   1. Assert: |underlyingSourceDict|["{{UnderlyingSource/type}}"] does not [=map/exist=] or
-     is "{{ReadableStreamType/transfer}}".
+     is "{{ReadableStreamType/owning}}".
   1. Let |sizeAlgorithm| be ! [$ExtractSizeAlgorithm$](|strategy|).
   1. Let |highWaterMark| be ? [$ExtractHighWaterMark$](|strategy|, 1).
   1. Perform ? [$SetUpReadableStreamDefaultControllerFromUnderlyingSource$]([=this=],
@@ -1533,8 +1533,9 @@ the following table:
    <td><dfn>\[[stream]]</dfn>
    <td class="non-normative">The {{ReadableStream}} instance controlled
   <tr>
-   <td><dfn>\[[isTransferring]]</dfn>
-   <td class="non-normative">A boolean flag indicating whether to transfer enqueued chunks
+   <td><dfn>\[[isOwning]]</dfn>
+   <td class="non-normative">A boolean flag indicating whether to take ownership of enqueued chunks
+   via transfer or serialization.
 </table>
 
 <h4 id="rs-default-controller-prototype">Methods and properties</h4>
@@ -1583,10 +1584,10 @@ the following table:
  The <dfn id="ref-for-rs-default-controller-enqueue" method
  for="ReadableStreamDefaultController">enqueue(|chunk|, |options|)</dfn> method steps are:
 
- 1. Let |transfer| be |options|["transfer"].
+ 1. Let |transferList| be |options|["transfer"].
  1. If ! [$ReadableStreamDefaultControllerCanCloseOrEnqueue$]([=this=]) is false, throw a
     {{TypeError}} exception.
- 1. Perform ? [$ReadableStreamDefaultControllerEnqueue$]([=this=], |chunk|, |transfer|).
+ 1. Perform ? [$ReadableStreamDefaultControllerEnqueue$]([=this=], |chunk|, |transferList|).
 </div>
 
 <div algorithm>
@@ -2248,7 +2249,7 @@ create them does not matter.
  objects|transferring=] their [=chunks=]. However, it does introduce a noticeable asymmetry between
  the two branches, and limits the possible [=chunks=] to serializable ones. [[!HTML]]
 
- If |stream| is a [=readable byte stream=], or if |stream| type is "{{ReadableStreamType/transfer}}",
+ If |stream| is a [=readable byte stream=], or if |stream| type is "{{ReadableStreamType/owning}}",
  then |cloneForBranch2| is ignored and chunks are cloned unconditionally.
 
  <p class="note">In this standard ReadableStreamTee is always called with |cloneForBranch2| set to
@@ -2260,7 +2261,7 @@ create them does not matter.
  1. Assert: |cloneForBranch2| is a boolean.
  1. If |stream|.[=ReadableStream/[[controller]]=] [=implements=] {{ReadableByteStreamController}},
     return ? [$ReadableByteStreamTee$](|stream|).
- 1. If |stream|.[=ReadableStream/[[controller]]=].[=ReadableStreamDefaultController/[[isTransferring]]=]
+ 1. If |stream|.[=ReadableStream/[[controller]]=].[=ReadableStreamDefaultController/[[isOwning]]=]
     is true, return ? [$ReadableStreamDefaultTee$](|stream|, true).
  1. Return ? [$ReadableStreamDefaultTee$](|stream|, |cloneForBranch2|).
 </div>
@@ -2972,7 +2973,7 @@ The following abstract operations support the implementation of the
  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. If |controller|.[=ReadableStreamDefaultController/[[isOwning]]=] is true, perform the following steps:
        1. Set |internalChunk| to [$StructuredTransferOrClone$](|chunk|, |transferList|).
        1. If |internalChunk| is an abrupt completion,
           1. Perform ! [$ReadableStreamDefaultControllerError$](|controller|, |internalChunk|.\[[Value]]).
@@ -3050,7 +3051,7 @@ The following abstract operations support the implementation of the
  <dfn abstract-op lt="SetUpReadableStreamDefaultController"
  id="set-up-readable-stream-default-controller">SetUpReadableStreamDefaultController(|stream|,
  |controller|, |startAlgorithm|, |pullAlgorithm|, |cancelAlgorithm|, |highWaterMark|,
- |sizeAlgorithm|, |isTransferring|)</dfn> performs the following steps:
+ |sizeAlgorithm|, |isOwning|)</dfn> performs the following steps:
 
  1. Assert: |stream|.[=ReadableStream/[[controller]]=] is undefined.
  1. Set |controller|.[=ReadableStreamDefaultController/[[stream]]=] to |stream|.
@@ -3061,8 +3062,8 @@ The following abstract operations support the implementation of the
     |controller|.[=ReadableStreamDefaultController/[[pulling]]=] to false.
  1. Set |controller|.[=ReadableStreamDefaultController/[[strategySizeAlgorithm]]=] to
     |sizeAlgorithm|, |controller|.[=ReadableStreamDefaultController/[[strategyHWM]]=] to
-    |highWaterMark| and |controller|.[=ReadableStreamDefaultController/[[isTransferring]]=] to
-    |isTransferring|.
+    |highWaterMark| and |controller|.[=ReadableStreamDefaultController/[[isOwning]]=] to
+    |isOwning|.
  1. Set |controller|.[=ReadableStreamDefaultController/[[pullAlgorithm]]=] to |pullAlgorithm|.
  1. Set |controller|.[=ReadableStreamDefaultController/[[cancelAlgorithm]]=] to |cancelAlgorithm|.
  1. Set |stream|.[=ReadableStream/[[controller]]=] to |controller|.
@@ -3087,8 +3088,8 @@ The following abstract operations support the implementation of the
  1. Let |startAlgorithm| be an algorithm that returns undefined.
  1. Let |pullAlgorithm| be an algorithm that returns [=a promise resolved with=] undefined.
  1. Let |cancelAlgorithm| be an algorithm that returns [=a promise resolved with=] undefined.
- 1. Let |isTransferring| be true if |underlyingSourceDict|["{{UnderlyingSource/type}}"] is
-    "{{ReadableStreamType/transfer}}" and false otherwise.
+ 1. Let |isOwning| be true if |underlyingSourceDict|["{{UnderlyingSource/type}}"] is
+    "{{ReadableStreamType/owning}}" and false otherwise.
  1. If |underlyingSourceDict|["{{UnderlyingSource/start}}"] [=map/exists=], then set
     |startAlgorithm| to an algorithm which returns the result of [=invoking=]
     |underlyingSourceDict|["{{UnderlyingSource/start}}"] with argument list
@@ -3102,7 +3103,7 @@ The following abstract operations support the implementation of the
     [=invoking=] |underlyingSourceDict|["{{UnderlyingSource/cancel}}"] with argument list
     «&nbsp;|reason|&nbsp;» and [=callback this value=] |underlyingSource|.
  1. Perform ? [$SetUpReadableStreamDefaultController$](|stream|, |controller|, |startAlgorithm|,
-    |pullAlgorithm|, |cancelAlgorithm|, |highWaterMark|, |sizeAlgorithm|, |isTransferring|).
+    |pullAlgorithm|, |cancelAlgorithm|, |highWaterMark|, |sizeAlgorithm|, |isOwning|).
 </div>
 
 <h4 id="rbs-controller-abstract-ops">Byte stream controllers</h4>
@@ -6393,7 +6394,7 @@ for="value-with-size">value</dfn> and <dfn for="value-with-size">size</dfn>.
  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| has a \[[isTransferring]] internal slot whose value is true, perform the following steps:
+ 1. If |container| has a \[[isOwning]] internal slot whose value is true, perform the following steps:
     1. Set |enqueuedValue| to [$StructuredTransferOrClone$](|value|, |transferList|).
     1. If |enqueuedValue| is an abrupt completion, return |enqueuedValue|.
  1. [=list/Append=] a new [=value-with-size=] with [=value-with-size/value=] |enqueuedValue| and
@@ -6416,7 +6417,7 @@ for="value-with-size">value</dfn> and <dfn for="value-with-size">size</dfn>.
  performs the following steps:
 
  1. Assert: |container| has \[[queue]] and \[[queueTotalSize]] internal slots.
- 1. If |container| has a \[[isTransferring]] internal slot whose value is true, perform the following steps until |container|.\[[queue]]
+ 1. If |container| has a \[[isOwning]] internal slot whose value is true, perform the following steps until |container|.\[[queue]]
     is [=list/is empty|empty=]:
     1. Let |chunk| be ! [$DequeueValue$]([=this=]).
     1. If |chunk| has [=closing steps=], perform the [=closing steps=] given |chunk|.
@@ -6631,8 +6632,7 @@ The following abstract operations are a grab-bag of utilities.
 <div algorithm>
  <dfn abstract-op lt="StructuredTransferOrClone">StructuredTransferOrClone(|value|, |transferList|)</dfn>
     performs the following steps:
- 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| ».
+ // FIXME: we might want to set |transferList| to « |value| » in case of transferable or ArrayBuffer objects.
  1. Let |serialized| be ! [$StructuredSerializeWithTransfer$](|value|, |transferList|).
  1. Let |deserialized| be ! [$StructuredDeserializeWithTransfer$](|serialized|, [=the current Realm=]).
  1. return |deserialized|.\[[Deserialized]].