Update web-platform-tests to revision 78f764c05c229883e87ad135c7153051a66e2851

tests/wpt/web-platform-tests/webrtc/RTCError.html

@@ -8,38 +8,43 @@
 'use strict';
 
 test(() => {
-  const error = new RTCError('message', {errorDetail:'data-channel-failure'});
+  const error = new RTCError({errorDetail:'data-channel-failure'}, 'message');
   assert_equals(error.message, 'message');
   assert_equals(error.errorDetail, 'data-channel-failure');
-}, 'RTCError constructor with message and errorDetail');
+}, 'RTCError constructor with errorDetail and message');
+
+test(() => {
+  const error = new RTCError({errorDetail:'data-channel-failure'});
+  assert_equals(error.message, '');
+}, 'RTCError constructor\'s message argument is optional');
 
 test(() => {
-  assert_throws(new TypeError(), () => {
-    new RTCError('message');
-  });
   assert_throws(new TypeError(), () => {
     new RTCError();
   });
-}, 'RTCError constructor throws TypeError if any argument is missing');
+  assert_throws(new TypeError(), () => {
+    new RTCError({});  // {errorDetail} is missing.
+  });
+}, 'RTCError constructor throws TypeError if arguments are missing');
 
 test(() => {
   assert_throws(new TypeError(), () => {
-    new RTCError('message', {errorDetail:'invalid-error-detail'});
+    new RTCError({errorDetail:'invalid-error-detail'}, 'message');
   });
 }, 'RTCError constructor throws TypeError if the errorDetail is invalid');
 
 test(() => {
-  const error = new RTCError('message', {errorDetail:'data-channel-failure'});
+  const error = new RTCError({errorDetail:'data-channel-failure'}, 'message');
   assert_equals(error.name, 'RTCError');
 }, 'RTCError.name is \'RTCError\'');
 
 test(() => {
-  const error = new RTCError('message', {errorDetail:'data-channel-failure'});
+  const error = new RTCError({errorDetail:'data-channel-failure'}, 'message');
   assert_equals(error.code, 0);
 }, 'RTCError.code is 0');
 
 test(() => {
-  const error = new RTCError('message', {errorDetail:'data-channel-failure'});
+  const error = new RTCError({errorDetail:'data-channel-failure'}, 'message');
   assert_throws(new TypeError(), () => {
     error.errorDetail = 'dtls-failure';
   });
@@ -49,9 +54,9 @@ test(() => {
   // Infers what are valid RTCErrorInit objects by passing them to the RTCError
   // constructor.
   assert_throws(new TypeError(), () => {
-    new RTCError('message', {});
+    new RTCError({}, 'message');
   });
-  new RTCError('message', {errorDetail:'data-channel-failure'});
+  new RTCError({errorDetail:'data-channel-failure'}, 'message');
 }, 'RTCErrorInit.errorDetail is the only required attribute');
 
 // All of these are number types (long or unsigned long).
@@ -63,18 +68,18 @@ const nullableAttributes = ['sdpLineNumber',
 
 nullableAttributes.forEach(attribute => {
   test(() => {
-    const error = new RTCError('message', {errorDetail:'data-channel-failure'});
+    const error = new RTCError({errorDetail:'data-channel-failure'}, 'message');
     assert_equals(error[attribute], null);
   }, 'RTCError.' + attribute + ' is null by default');
 
   test(() => {
-    const error = new RTCError('message', {errorDetail:'data-channel-failure',
-                                           [attribute]: 0});
+    const error = new RTCError(
+        {errorDetail:'data-channel-failure', [attribute]: 0}, 'message');
     assert_equals(error[attribute], 0);
   }, 'RTCError.' + attribute + ' is settable by constructor');
 
   test(() => {
-    const error = new RTCError('message', {errorDetail:'data-channel-failure'});
+    const error = new RTCError({errorDetail:'data-channel-failure'}, 'message');
     assert_throws(new TypeError(), () => {
       error[attribute] = 42;
     });

tests/wpt/web-platform-tests/webrtc/RTCIceTransport-extension.https.html

@@ -260,7 +260,7 @@ promise_test(async t => {
     const [ localTransport, remoteTransport ] =
         makeAndGatherTwoIceTransports(t);
     localTransport.start(remoteTransport.getLocalParameters(), role);
-    localTransport.start(remoteTransport.getLocalParameters(), role);
+    remoteTransport.start(localTransport.getLocalParameters(), role);
     const localWatcher = new EventWatcher(t, localTransport, 'statechange');
     const remoteWatcher = new EventWatcher(t, remoteTransport, 'statechange');
     await Promise.all([
@@ -276,13 +276,10 @@ promise_test(async t => {
 });
 
 promise_test(async t => {
-  async function waitForConnectedThenSelectedCandidatePairChange(t, transport,
+  async function waitForSelectedCandidatePairChangeThenConnected(t, transport,
       transportName) {
     const watcher = new EventWatcher(t, transport,
         [ 'statechange', 'selectedcandidatepairchange' ]);
-    await watcher.wait_for('statechange');
-    assert_equals(transport.state, 'connected',
-        `${transportName} state should be 'connected'`);
     await watcher.wait_for('selectedcandidatepairchange');
     const selectedCandidatePair = transport.getSelectedCandidatePair();
     assert_not_equals(selectedCandidatePair, null,
@@ -300,13 +297,16 @@ promise_test(async t => {
                 candidate === selectedCandidatePair.remote.candidate),
         `${transportName} selected candidate pair local should be in the ` +
         'list of remote candidates');
+    await watcher.wait_for('statechange');
+    assert_equals(transport.state, 'connected',
+        `${transportName} state should be 'connected'`);
   }
   const [ localTransport, remoteTransport ] =
       makeGatherAndStartTwoIceTransports(t);
   await Promise.all([
-    waitForConnectedThenSelectedCandidatePairChange(t, localTransport,
+    waitForSelectedCandidatePairChangeThenConnected(t, localTransport,
         'local transport'),
-    waitForConnectedThenSelectedCandidatePairChange(t, remoteTransport,
+    waitForSelectedCandidatePairChangeThenConnected(t, remoteTransport,
         'remote transport'),
   ]);
 }, 'Selected candidate pair changes once the RTCIceTransports connect.');

tests/wpt/web-platform-tests/webrtc/RTCRtpParameters-encodings.html

@@ -220,8 +220,8 @@
   promise_test(async t => {
     const pc = new RTCPeerConnection();
     t.add_cleanup(() => pc.close());
-    const { sender } = pc.addTransceiver('audio', {
-      sendEncodings: [{ rid: 'foo' }],
+    const { sender } = pc.addTransceiver('video', {
+      sendEncodings: [{ rid: 'foo' }, { rid: 'baz' }],
     });
     await doOfferAnswerExchange(t, pc);
 

tests/wpt/web-platform-tests/webrtc/RTCRtpSender-transport.https.html

@@ -1,5 +1,6 @@
 <!doctype html>
 <meta charset=utf-8>
+<meta name="timeout" content="long">
 <title>RTCRtpSender.transport</title>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
@@ -35,6 +36,7 @@
     const [transceiver] = caller.getTransceivers();
     assert_equals(transceiver.sender.transport,
                   transceiver.receiver.transport);
+    assert_not_equals(sender.transport.iceTransport, null);
   }, 'RTCRtpSender/receiver.transport has a value when connected');
 
   // Test with multiple tracks, and checking details of when things show up

tests/wpt/web-platform-tests/webrtc/RTCRtpTransceiver.https.html

@@ -441,6 +441,42 @@
     await pc1.setRemoteDescription(answer);
   };
 
+  const checkNoMidAnswer = async t => {
+    const pc1 = new RTCPeerConnection();
+    const pc2 = new RTCPeerConnection();
+    t.add_cleanup(() => pc1.close());
+    t.add_cleanup(() => pc2.close());
+
+    const stream = await navigator.mediaDevices.getUserMedia({audio: true});
+    t.add_cleanup(() => stopTracks(stream));
+    const track = stream.getAudioTracks()[0];
+    pc1.addTrack(track, stream);
+
+    const offer = await pc1.createOffer();
+    await pc1.setLocalDescription(offer);
+    await pc2.setRemoteDescription(offer);
+    let answer = await pc2.createAnswer();
+    // Remove mid attr
+    answer.sdp = answer.sdp.replace("a=mid:", "a=unknownattr:");
+    // Remove group attr also
+    answer.sdp = answer.sdp.replace("a=group:", "a=unknownattr:");
+    await pc1.setRemoteDescription(answer);
+
+    hasPropsAndUniqueMids(pc1.getTransceivers(),
+      [
+        {
+          receiver: {track: {kind: "audio"}},
+          sender: {track: {kind: "audio"}},
+          direction: "sendrecv",
+          currentDirection: "sendonly",
+          stopped: false
+        }
+      ]);
+
+    const reoffer = await pc1.createOffer();
+    await pc1.setLocalDescription(reoffer);
+  };
+
   const checkAddTransceiverNoTrackDoesntPair = async t => {
     const pc1 = new RTCPeerConnection();
     const pc2 = new RTCPeerConnection();
@@ -2156,6 +2192,7 @@ const tests = [
   checkAddTransceiverWithSetRemoteOfferNoSend,
   checkAddTransceiverBadKind,
   checkNoMidOffer,
+  checkNoMidAnswer,
   checkSetDirection,
   checkCurrentDirection,
   checkSendrecvWithNoSendTrack,

tests/wpt/web-platform-tests/webrtc/protocol/README.txt

@@ -14,6 +14,8 @@ The main specifications are given in the following internet-drafts:
 - draft-ietf-rtcweb-fec
 - draft-ietf-rtcweb-data-protocol
 - draft-ietf-rtcweb-data-channel
+- draft-ietf-mmusic-sdp-simulcast
+- draft-ietf-mmusic-rid
 
 - RFC 7742, "WebRTC Video Processing and Codec Requirements"
 - RFC 7874, "WebRTC Audio Codec and Processing Requirements"

tests/wpt/web-platform-tests/webrtc/protocol/simulcast-offer.html

@@ -0,0 +1,33 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>RTCPeerConnection Simulcast Offer</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+'use strict';
+
+// Tests for the construction of offers with simulcast according to:
+// draft-ietf-mmusic-sdp-simulcast-13
+// draft-ietf-mmusic-rid-15
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+  const expected_rids = ['foo', 'bar', 'baz'];
+  pc.addTransceiver('video', {
+    sendEncodings: expected_rids.map(rid => ({rid}))
+  });
+
+  const offer = await pc.createOffer();
+  let offer_lines = offer.sdp.split('\r\n');
+  // Check for a RID line for each layer.
+  for (const rid of expected_rids) {
+    let result = offer_lines.find(line => line.startsWith(`a=rid:${rid}`));
+    assert_not_equals(result, undefined, `RID attribute for '${rid}' missing.`);
+  }
+
+  // Check for simulcast attribute with send direction and all RIDs.
+  let result = offer_lines.find(
+      line => line.startsWith(`a=simulcast:send ${expected_rids.join(';')}`));
+  assert_not_equals(result, undefined, "Could not find simulcast attribute.");
+}, 'createOffer() with multiple send encodings should create simulcast offer');
+</script>