[RTCInsertableStreams] Add support for readable/writable fields

This CL adds the readable and writable fields to the
RTCInsertableStreams dictionary.
These are equivalent to and will replace readableStream and writableStream.
The reason for this is consistency with other APIs that use stream pairs.

Drive-by: rename RTCCodedVideoFrameType to RTCEncodedVideoFrameType to
match the spec and update tests to comply with other API changes.

Bug: 1119653
Change-Id: I64bcafb2602fb952722f1845abaeebd09f3e77d3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2366592Reviewed-by: Harald Alvestrand <hta@chromium.org>
Commit-Queue: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800032}

third_party/blink/renderer/modules/peerconnection/rtc_encoded_video_frame.idl

@@ -5,7 +5,7 @@
 // https://github.com/alvestrand/webrtc-media-streams/blob/master/explainer.md#api
 // TODO(crbug.com/1052765): Add link to standard when available.
 
-enum RTCCodedVideoFrameType {
+enum RTCEncodedVideoFrameType {
     "empty",
     "key",
     "delta",
@@ -16,7 +16,7 @@ enum RTCCodedVideoFrameType {
     Exposed=Window,
     RuntimeEnabled=RTCInsertableStreams
 ] interface RTCEncodedVideoFrame {
-    readonly attribute RTCCodedVideoFrameType type;
+    readonly attribute RTCEncodedVideoFrameType type;
     readonly attribute unsigned long long timestamp;  // microseconds
     attribute ArrayBuffer data;
     RTCEncodedVideoFrameMetadata getMetadata();

third_party/blink/renderer/modules/peerconnection/rtc_insertable_streams.idl

@@ -2,10 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://github.com/alvestrand/webrtc-media-streams/blob/master/explainer.md#api
-// TODO(guidou): Add standards link when available.
+// https://w3c.github.io/webrtc-insertable-streams/#dictdef-rtcinsertablestreams
 
 dictionary RTCInsertableStreams {
-    ReadableStream readableStream;
-    WritableStream writableStream;
+    ReadableStream readable;
+    WritableStream writable;
+
+    // Deprecated
+    [RuntimeEnabled=RTCInsertableStreams] ReadableStream readableStream;
+    [RuntimeEnabled=RTCInsertableStreams] WritableStream writableStream;
 };

third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver.cc

@@ -399,10 +399,12 @@ void RTCRtpReceiver::InitializeEncodedAudioStreams(ScriptState* script_state) {
           /*is_receiver=*/true);
   // The high water mark for the readable stream is set to 0 so that frames are
   // removed from the queue right away, without introducing a new buffer.
-  encoded_audio_streams_->setReadableStream(
+  ReadableStream* readable_stream =
       ReadableStream::CreateWithCountQueueingStrategy(
           script_state, audio_from_depacketizer_underlying_source_,
-          /*high_water_mark=*/0));
+          /*high_water_mark=*/0);
+  encoded_audio_streams_->setReadableStream(readable_stream);
+  encoded_audio_streams_->setReadable(readable_stream);
 
   // Set up writable.
   audio_to_decoder_underlying_sink_ =
@@ -418,10 +420,12 @@ void RTCRtpReceiver::InitializeEncodedAudioStreams(ScriptState* script_state) {
               WrapWeakPersistent(this)));
   // The high water mark for the stream is set to 1 so that the stream seems
   // ready to write, but without queuing frames.
-  encoded_audio_streams_->setWritableStream(
+  WritableStream* writable_stream =
       WritableStream::CreateWithCountQueueingStrategy(
           script_state, audio_to_decoder_underlying_sink_,
-          /*high_water_mark=*/1));
+          /*high_water_mark=*/1);
+  encoded_audio_streams_->setWritableStream(writable_stream);
+  encoded_audio_streams_->setWritable(writable_stream);
 }
 
 void RTCRtpReceiver::OnAudioFrameFromDepacketizer(
@@ -467,10 +471,12 @@ void RTCRtpReceiver::InitializeEncodedVideoStreams(ScriptState* script_state) {
                     WrapWeakPersistent(this)));
   // The high water mark for the readable stream is set to 0 so that frames are
   // removed from the queue right away, without introducing a new buffer.
-  encoded_video_streams_->setReadableStream(
+  ReadableStream* readable_stream =
       ReadableStream::CreateWithCountQueueingStrategy(
           script_state, video_from_depacketizer_underlying_source_,
-          /*high_water_mark=*/0));
+          /*high_water_mark=*/0);
+  encoded_video_streams_->setReadableStream(readable_stream);
+  encoded_video_streams_->setReadable(readable_stream);
 
   // Set up writable.
   video_to_decoder_underlying_sink_ =
@@ -486,10 +492,12 @@ void RTCRtpReceiver::InitializeEncodedVideoStreams(ScriptState* script_state) {
               WrapWeakPersistent(this)));
   // The high water mark for the stream is set to 1 so that the stream seems
   // ready to write, but without queuing frames.
-  encoded_video_streams_->setWritableStream(
+  WritableStream* writable_stream =
       WritableStream::CreateWithCountQueueingStrategy(
           script_state, video_to_decoder_underlying_sink_,
-          /*high_water_mark=*/1));
+          /*high_water_mark=*/1);
+  encoded_video_streams_->setWritableStream(writable_stream);
+  encoded_video_streams_->setWritable(writable_stream);
 }
 
 void RTCRtpReceiver::OnVideoFrameFromDepacketizer(

third_party/blink/renderer/modules/peerconnection/rtc_rtp_sender.cc

@@ -806,10 +806,12 @@ void RTCRtpSender::InitializeEncodedAudioStreams(ScriptState* script_state) {
           /*is_receiver=*/false);
   // The high water mark for the readable stream is set to 0 so that frames are
   // removed from the queue right away, without introducing any buffering.
-  encoded_audio_streams_->setReadableStream(
+  ReadableStream* readable_stream =
       ReadableStream::CreateWithCountQueueingStrategy(
           script_state, audio_from_encoder_underlying_source_,
-          /*high_water_mark=*/0));
+          /*high_water_mark=*/0);
+  encoded_audio_streams_->setReadableStream(readable_stream);
+  encoded_audio_streams_->setReadable(readable_stream);
 
   // Set up writable stream.
   audio_to_packetizer_underlying_sink_ =
@@ -824,10 +826,12 @@ void RTCRtpSender::InitializeEncodedAudioStreams(ScriptState* script_state) {
               WrapWeakPersistent(this)));
   // The high water mark for the stream is set to 1 so that the stream is
   // ready to write, but without queuing frames.
-  encoded_audio_streams_->setWritableStream(
+  WritableStream* writable_stream =
       WritableStream::CreateWithCountQueueingStrategy(
           script_state, audio_to_packetizer_underlying_sink_,
-          /*high_water_mark=*/1));
+          /*high_water_mark=*/1);
+  encoded_audio_streams_->setWritableStream(writable_stream);
+  encoded_audio_streams_->setWritable(writable_stream);
 }
 
 void RTCRtpSender::OnAudioFrameFromEncoder(
@@ -867,10 +871,12 @@ void RTCRtpSender::InitializeEncodedVideoStreams(ScriptState* script_state) {
                     WrapWeakPersistent(this)));
   // The high water mark for the readable stream is set to 0 so that frames are
   // removed from the queue right away, without introducing any buffering.
-  encoded_video_streams_->setReadableStream(
+  ReadableStream* readable_stream =
       ReadableStream::CreateWithCountQueueingStrategy(
           script_state, video_from_encoder_underlying_source_,
-          /*high_water_mark=*/0));
+          /*high_water_mark=*/0);
+  encoded_video_streams_->setReadableStream(readable_stream);
+  encoded_video_streams_->setReadable(readable_stream);
 
   // Set up writable stream.
   video_to_packetizer_underlying_sink_ =
@@ -885,10 +891,12 @@ void RTCRtpSender::InitializeEncodedVideoStreams(ScriptState* script_state) {
               WrapWeakPersistent(this)));
   // The high water mark for the stream is set to 1 so that the stream is
   // ready to write, but without queuing frames.
-  encoded_video_streams_->setWritableStream(
+  WritableStream* writable_stream =
       WritableStream::CreateWithCountQueueingStrategy(
           script_state, video_to_packetizer_underlying_sink_,
-          /*high_water_mark=*/1));
+          /*high_water_mark=*/1);
+  encoded_video_streams_->setWritableStream(writable_stream);
+  encoded_video_streams_->setWritable(writable_stream);
 }
 
 void RTCRtpSender::OnVideoFrameFromEncoder(

third_party/blink/web_tests/external/wpt/webrtc-insertable-streams/RTCEncodedAudioFrame-serviceworker-failure.https.html

@@ -10,7 +10,7 @@
 <script>
 "use strict";
 promise_test(async t => {
-  const caller = new RTCPeerConnection({forceEncodedAudioInsertableStreams:true});
+  const caller = new RTCPeerConnection({encodedInsertableStreams:true});
   t.add_cleanup(() => caller.close());
   const callee = new RTCPeerConnection();
   t.add_cleanup(() => callee.close());
@@ -20,9 +20,9 @@ promise_test(async t => {
   t.add_cleanup(() => track.stop());
 
   const sender = caller.addTrack(track)
-  const streams = sender.createEncodedAudioStreams();
-  const reader = streams.readableStream.getReader();
-  const writer = streams.writableStream.getWriter();
+  const streams = sender.createEncodedStreams();
+  const reader = streams.readable.getReader();
+  const writer = streams.writable.getWriter();
 
   exchangeIceCandidates(caller, callee);
   await exchangeOfferAnswer(caller, callee);

third_party/blink/web_tests/external/wpt/webrtc-insertable-streams/RTCEncodedVideoFrame-serviceworker-failure.https.html

@@ -10,7 +10,7 @@
 <script>
 "use strict";
 promise_test(async t => {
-  const caller = new RTCPeerConnection({forceEncodedVideoInsertableStreams:true});
+  const caller = new RTCPeerConnection({encodedInsertableStreams:true});
   t.add_cleanup(() => caller.close());
   const callee = new RTCPeerConnection();
   t.add_cleanup(() => callee.close());
@@ -20,9 +20,9 @@ promise_test(async t => {
   t.add_cleanup(() => videoTrack.stop());
 
   const videoSender = caller.addTrack(videoTrack)
-  const senderStreams = videoSender.createEncodedVideoStreams();
-  const senderReader = senderStreams.readableStream.getReader();
-  const senderWriter = senderStreams.writableStream.getWriter();
+  const senderStreams = videoSender.createEncodedStreams();
+  const senderReader = senderStreams.readable.getReader();
+  const senderWriter = senderStreams.writable.getWriter();
 
   exchangeIceCandidates(caller, callee);
   await exchangeOfferAnswer(caller, callee);

third_party/blink/web_tests/fast/peerconnection/RTCPeerConnection-insertable-streams-audio.html

@@ -21,8 +21,8 @@ async function testAudioFlow(t, negotiationFunction) {
 
   const audioSender = caller.addTrack(audioTrack)
   const senderStreams = audioSender.createEncodedStreams();
-  const senderReader = senderStreams.readableStream.getReader();
-  const senderWriter = senderStreams.writableStream.getWriter();
+  const senderReader = senderStreams.readable.getReader();
+  const senderWriter = senderStreams.writable.getWriter();
 
   const frameInfos = [];
   const numFramesPassthrough = 5;
@@ -37,8 +37,8 @@ async function testAudioFlow(t, negotiationFunction) {
 
       const receiverStreams =
           audioReceiver.createEncodedStreams();
-      const receiverReader = receiverStreams.readableStream.getReader();
-      const receiverWriter = receiverStreams.writableStream.getWriter();
+      const receiverReader = receiverStreams.readable.getReader();
+      const receiverWriter = receiverStreams.writable.getWriter();
 
       const maxFramesToReceive = numFramesToSend;
       let numVerifiedFrames = 0;
@@ -177,8 +177,8 @@ promise_test(async t => {
 
   const senderWorker = new Worker('RTCPeerConnection-sender-worker-single-frame.js')
   senderWorker.postMessage(
-    {readableStream: senderStreams.readableStream},
-    [senderStreams.readableStream]);
+    {readableStream: senderStreams.readable},
+    [senderStreams.readable]);
 
   let expectedFrameData = null;
   let verifiedFrameData = false;
@@ -238,7 +238,7 @@ promise_test(async t => {
 
   await promise_rejects_dom(
       t, 'OperationError',
-      streams.readableStream.pipeThrough(transformer).pipeTo(streams.writableStream));
+      streams.readable.pipeThrough(transformer).pipeTo(streams.writable));
 }, 'Enqueuing the same frame twice fails');
 
 promise_test(async t => {
@@ -252,17 +252,17 @@ promise_test(async t => {
   t.add_cleanup(() => audioTrack.stop());
 
   const audioSender = caller.addTrack(audioTrack)
-  const senderStreams = audioSender.createEncodedAudioStreams();
-  const senderReader = senderStreams.readableStream.getReader();
-  const senderWriter = senderStreams.writableStream.getWriter();
+  const senderStreams = audioSender.createEncodedStreams();
+  const senderReader = senderStreams.readable.getReader();
+  const senderWriter = senderStreams.writable.getWriter();
 
   let sentFrameInfo = null;
   const ontrackPromise = new Promise(resolve => {
     callee.ontrack = e => {
       const audioReceiver = e.receiver;
 
-      const receiverStreams = audioReceiver.createEncodedAudioStreams();
-      const receiverReader = receiverStreams.readableStream.getReader();
+      const receiverStreams = audioReceiver.createEncodedStreams();
+      const receiverReader = receiverStreams.readable.getReader();
       receiverReader.read().then(t.step_func(receivedResult => {
         assert_true(areFrameInfosEqual(receivedResult.value, sentFrameInfo));
         resolve();

third_party/blink/web_tests/fast/peerconnection/RTCPeerConnection-insertable-streams-simulcast.html

@@ -29,9 +29,9 @@ promise_test(async t => {
       }
     });
     const receiverStreams = e.receiver.createEncodedStreams();
-    receiverStreams.readableStream
+    receiverStreams.readable
         .pipeThrough(receiverTransformer)
-        .pipeTo(receiverStreams.writableStream);
+        .pipeTo(receiverStreams.writable);
 
     const stream = e.streams[0];
     const v = document.createElement('video');
@@ -60,9 +60,9 @@ promise_test(async t => {
       controller.enqueue(chunk);
     }
   });
-  senderStreams.readableStream
+  senderStreams.readable
       .pipeThrough(senderTransformer)
-      .pipeTo(senderStreams.writableStream);
+      .pipeTo(senderStreams.writable);
 
   const offer = await pc1.createOffer();
   await pc1.setLocalDescription(offer),

third_party/blink/web_tests/fast/peerconnection/RTCPeerConnection-insertable-streams.html

@@ -24,8 +24,8 @@ async function testVideoFlow(t, negotiationFunction) {
 
   const videoSender = caller.addTrack(videoTrack)
   const senderStreams = videoSender.createEncodedStreams();
-  const senderReader = senderStreams.readableStream.getReader();
-  const senderWriter = senderStreams.writableStream.getWriter();
+  const senderReader = senderStreams.readable.getReader();
+  const senderWriter = senderStreams.writable.getWriter();
 
   const frameInfos = [];
   const numFramesPassthrough = 5;
@@ -40,8 +40,8 @@ async function testVideoFlow(t, negotiationFunction) {
 
       const receiverStreams =
           videoReceiver.createEncodedStreams();
-      const receiverReader = receiverStreams.readableStream.getReader();
-      const receiverWriter = receiverStreams.writableStream.getWriter();
+      const receiverReader = receiverStreams.readable.getReader();
+      const receiverWriter = receiverStreams.writable.getWriter();
 
       const maxFramesToReceive = numFramesToSend;
       let numVerifiedFrames = 0;
@@ -185,8 +185,8 @@ promise_test(async t => {
 
   const senderWorker = new Worker('RTCPeerConnection-sender-worker-single-frame.js')
   senderWorker.postMessage(
-    {readableStream: senderStreams.readableStream},
-    [senderStreams.readableStream]);
+    {readableStream: senderStreams.readable},
+    [senderStreams.readable]);
 
   let expectedFrameData = null;
   let verifiedFrameData = false;
@@ -286,14 +286,14 @@ promise_test(async t => {
 
   const sender = caller.addTrack(track)
   const senderStreams = sender.createEncodedStreams();
-  const senderReader = senderStreams.readableStream.getReader();
-  const senderWriter = senderStreams.writableStream.getWriter();
+  const senderReader = senderStreams.readable.getReader();
+  const senderWriter = senderStreams.writable.getWriter();
   const numFramesToSend = 20;
 
   const ontrackPromise = new Promise((resolve, reject) => {
     callee.ontrack = async e => {
       const receiverStreams = e.receiver.createEncodedStreams();
-      const receiverReader = receiverStreams.readableStream.getReader();
+      const receiverReader = receiverStreams.readable.getReader();
 
       let numReceivedKeyFrames = 0;
       let numReceivedDeltaFrames = 0;
@@ -361,13 +361,13 @@ promise_test(async t => {
 
   await promise_rejects_dom(
       t, 'OperationError',
-      streams.readableStream.pipeThrough(transformer).pipeTo(streams.writableStream));
+      streams.readable.pipeThrough(transformer).pipeTo(streams.writable));
 }, 'Enqueuing the same frame twice fails');
 
 promise_test(async t => {
-  const caller = new RTCPeerConnection({forceEncodedVideoInsertableStreams:true});
+  const caller = new RTCPeerConnection({encodedInsertableStreams:true});
   t.add_cleanup(() => caller.close());
-  const callee = new RTCPeerConnection({forceEncodedVideoInsertableStreams:true});
+  const callee = new RTCPeerConnection({encodedInsertableStreams:true});
   t.add_cleanup(() => callee.close());
 
   const stream = await navigator.mediaDevices.getUserMedia({video:true});
@@ -375,17 +375,17 @@ promise_test(async t => {
   t.add_cleanup(() => videoTrack.stop());
 
   const videoSender = caller.addTrack(videoTrack)
-  const senderStreams = videoSender.createEncodedVideoStreams();
-  const senderReader = senderStreams.readableStream.getReader();
-  const senderWriter = senderStreams.writableStream.getWriter();
+  const senderStreams = videoSender.createEncodedStreams();
+  const senderReader = senderStreams.readable.getReader();
+  const senderWriter = senderStreams.writable.getWriter();
 
   let sentFrameInfo = null;
   const ontrackPromise = new Promise(resolve => {
     callee.ontrack = t.step_func(async e => {
       const videoReceiver = e.receiver;
 
-      const receiverStreams = videoReceiver.createEncodedVideoStreams();
-      const receiverReader = receiverStreams.readableStream.getReader();
+      const receiverStreams = videoReceiver.createEncodedStreams();
+      const receiverReader = receiverStreams.readable.getReader();
       receiverReader.read().then(t.step_func(receivedResult => {
         assert_true(areFrameInfosEqual(receivedResult.value, sentFrameInfo));
         resolve();