Owning WritableStream reference implementation

Author: youennf

reference-implementation/lib/UnderlyingSink.webidl

@@ -3,10 +3,12 @@ dictionary UnderlyingSink {
   UnderlyingSinkWriteCallback write;
   UnderlyingSinkCloseCallback close;
   UnderlyingSinkAbortCallback abort;
-  any type;
+  WritableStreamType type;
 };
 
 callback UnderlyingSinkStartCallback = any (WritableStreamDefaultController controller);
 callback UnderlyingSinkWriteCallback = Promise<undefined> (any chunk, WritableStreamDefaultController controller);
 callback UnderlyingSinkCloseCallback = Promise<undefined> ();
 callback UnderlyingSinkAbortCallback = Promise<undefined> (optional any reason);
+
+enum WritableStreamType { "owning" };

reference-implementation/lib/WritableStream-impl.js

@@ -12,7 +12,7 @@ exports.implementation = class WritableStreamImpl {
       underlyingSink = null;
     }
     const underlyingSinkDict = UnderlyingSink.convert(underlyingSink);
-    if ('type' in underlyingSinkDict) {
+    if ('type' in underlyingSinkDict && underlyingSinkDict.type !== 'owning') {
       throw new RangeError('Invalid type is specified');
     }
 

reference-implementation/lib/WritableStreamDefaultWriter-impl.js

@@ -59,12 +59,13 @@ exports.implementation = class WritableStreamDefaultWriterImpl {
     aos.WritableStreamDefaultWriterRelease(this);
   }
 
-  write(chunk) {
+  write(chunk, options) {
+    const transferList = options ? options.transfer : undefined;
     if (this._stream === undefined) {
       return promiseRejectedWith(defaultWriterLockException('write to'));
     }
 
-    return aos.WritableStreamDefaultWriterWrite(this, chunk);
+    return aos.WritableStreamDefaultWriterWrite(this, chunk, transferList);
   }
 };
 

reference-implementation/lib/WritableStreamDefaultWriter.webidl

@@ -1,3 +1,7 @@
+dictionary StructuredSerializeOptions {
+  sequence<object> transfer = [];
+};
+
 [Exposed=(Window,Worker,Worklet)]
 interface WritableStreamDefaultWriter {
   constructor(WritableStream stream);
@@ -9,5 +13,5 @@ interface WritableStreamDefaultWriter {
   Promise<undefined> abort(optional any reason);
   Promise<undefined> close();
   undefined releaseLock();
-  Promise<undefined> write(optional any chunk);
+  Promise<undefined> write(optional any chunk, optional StructuredSerializeOptions options = { });
 };

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

@@ -529,7 +529,7 @@ function WritableStreamDefaultWriterWrite(writer, chunk) {
 // Default controllers
 
 function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,
-                                              abortAlgorithm, highWaterMark, sizeAlgorithm) {
+                                              abortAlgorithm, highWaterMark, sizeAlgorithm, isOwning) {
   assert(WritableStream.isImpl(stream));
   assert(stream._controller === undefined);
 
@@ -551,6 +551,8 @@ function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm
   controller._closeAlgorithm = closeAlgorithm;
   controller._abortAlgorithm = abortAlgorithm;
 
+  controller._isOwning = isOwning;
+
   const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
   WritableStreamUpdateBackpressure(stream, backpressure);
 
@@ -579,6 +581,7 @@ function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyi
   let writeAlgorithm = () => promiseResolvedWith(undefined);
   let closeAlgorithm = () => promiseResolvedWith(undefined);
   let abortAlgorithm = () => promiseResolvedWith(undefined);
+  const isOwning = underlyingSinkDict.type === 'owning';
 
   if ('start' in underlyingSinkDict) {
     startAlgorithm = () => underlyingSinkDict.start.call(underlyingSink, controller);
@@ -594,8 +597,8 @@ function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyi
   }
 
   SetUpWritableStreamDefaultController(
-    stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm
-  );
+    stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm,
+    isOwning);
 }
 
 function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {