From 0e97d09a90f8e384d0a819f9f9be2ea7e17302bb Mon Sep 17 00:00:00 2001
From: youennf <youennf@users.noreply.github.com>
Date: Sat, 23 Mar 2019 19:02:56 +0100
Subject: [PATCH] Data channel tests updated by Lennart Grahl
 <lennart.grahl@gmail.com> (#16038)

* Data channel tests modernized/updated by Lennart Grahl <lennart.grahl@gmail.com>

* Fix according Harald comments
---
 webrtc/README.md                              |  12 +
 webrtc/RTCDataChannel-bufferedAmount.html     | 372 ++++++----
 webrtc/RTCDataChannel-id.html                 | 380 ++++++++--
 webrtc/RTCDataChannelEvent-constructor.html   |  17 +-
 .../RTCPeerConnection-createDataChannel.html  | 696 ++++++++++++------
 webrtc/RTCPeerConnection-helper.js            |  74 +-
 webrtc/RTCPeerConnection-ondatachannel.html   | 534 +++++++++-----
 webrtc/RTCSctpTransport-constructor.html      | 198 +++--
 webrtc/RTCSctpTransport-maxMessageSize.html   | 278 +++----
 webrtc/historical.html                        |  11 +-
 10 files changed, 1754 insertions(+), 818 deletions(-)
 create mode 100644 webrtc/README.md

diff --git a/webrtc/README.md b/webrtc/README.md
new file mode 100644
index 00000000000000..4477e4f375fdc0
--- /dev/null
+++ b/webrtc/README.md
@@ -0,0 +1,12 @@
+# WebRTC
+
+This directory contains the WebRTC test suite.
+
+## Acknowledgements
+
+Some data channel tests are based on the [data channel conformance test
+suite][nplab-webrtc-dc-playground] of the Network Programming Lab of the Münster
+University of Applied Sciences. We would like to thank Peter Titz, Felix Weinrank and Timo
+Völker for agreeing to contribute their test cases to this repository.
+
+[nplab-webrtc-dc-playground]: https://github.com/nplab/WebRTC-Data-Channel-Playground/tree/master/conformance-tests
diff --git a/webrtc/RTCDataChannel-bufferedAmount.html b/webrtc/RTCDataChannel-bufferedAmount.html
index f4a7104a4e5f33..b982b29b3b957e 100644
--- a/webrtc/RTCDataChannel-bufferedAmount.html
+++ b/webrtc/RTCDataChannel-bufferedAmount.html
@@ -5,166 +5,222 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="RTCPeerConnection-helper.js"></script>
 <script>
-  'use strict';
-
-  // Test is based on the following editor draft:
-  // https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
-
-  // The following helper functions are called from RTCPeerConnection-helper.js:
-  //  createDataChannelPair
-  //  awaitMessage
-  //  blobToArrayBuffer
-  //  assert_equals_array_buffer
-
-  /*
-    6.2.  RTCDataChannel
-      interface RTCDataChannel : EventTarget {
-        ...
-        readonly  attribute unsigned long       bufferedAmount;
-        void send(USVString data);
-        void send(Blob data);
-        void send(ArrayBuffer data);
-        void send(ArrayBufferView data);
-      };
-
-      bufferedAmount
-        The bufferedAmount attribute must return the number of bytes of application
-        data (UTF-8 text and binary data) that have been queued using send() but that,
-        as of the last time the event loop started executing a task, had not yet been
-        transmitted to the network. (This thus includes any text sent during the
-        execution of the current task, regardless of whether the user agent is able
-        to transmit text asynchronously with script execution.) This does not include
-        framing overhead incurred by the protocol, or buffering done by the operating
-        system or network hardware. If the channel is closed, this attribute's value
-        will only increase with each call to the send() method (the attribute does not
-        reset to zero once the channel closes).
-
-
-    [WebMessaging]
-    interface MessageEvent : Event {
-      readonly attribute any data;
+'use strict';
+
+// Test is based on the following revision:
+// https://rawgit.com/w3c/webrtc-pc/1cc5bfc3ff18741033d804c4a71f7891242fb5b3/webrtc.html
+
+// The following helper functions are called from RTCPeerConnection-helper.js:
+//  createDataChannelPair
+//  awaitMessage
+
+/*
+  6.2.  RTCDataChannel
+    interface RTCDataChannel : EventTarget {
       ...
+      readonly  attribute unsigned long       bufferedAmount;
+      void send(USVString data);
+      void send(Blob data);
+      void send(ArrayBuffer data);
+      void send(ArrayBufferView data);
     };
-   */
-
-  // Simple ASCII encoded string
-  const helloString = 'hello';
-  // ASCII encoded buffer representation of the string
-  const helloBuffer = Uint8Array.of(0x68, 0x65, 0x6c, 0x6c, 0x6f);
-  const helloBlob = new Blob([helloBuffer]);
-
-  // Unicode string with multiple code units
-  const unicodeString = '世界你好';
-  // UTF-8 encoded buffer representation of the string
-  const unicodeBuffer = Uint8Array.of(
-    0xe4, 0xb8, 0x96, 0xe7, 0x95, 0x8c,
-    0xe4, 0xbd, 0xa0, 0xe5, 0xa5, 0xbd);
-
-  /*
-    6.2.  send()
-      3.  Execute the sub step that corresponds to the type of the methods argument:
-
-          string object
-            Let data be the object and increase the bufferedAmount attribute
-            by the number of bytes needed to express data as UTF-8.
-   */
-  promise_test(t => {
-    return createDataChannelPair()
-    .then(([channel1, channel2]) => {
-      channel1.send(unicodeString);
-      assert_equals(channel1.bufferedAmount, unicodeBuffer.byteLength,
-        'Expect bufferedAmount to be the byte length of the unicode string');
-
-      return awaitMessage(channel2)
-      .then(message => {
-        assert_equals(channel1.bufferedAmount, 0,
-          'Expect sender bufferedAmount to be reduced after message is sent');
-      });
-    });
-  }, 'bufferedAmount should increase to byte length of encoded unicode string sent');
-
-  /*
-    6.2. send()
-      3.  Execute the sub step that corresponds to the type of the methods argument:
-          ArrayBuffer object
-            Let data be the data stored in the buffer described by the ArrayBuffer
-            object and increase the bufferedAmount attribute by the length of the
-            ArrayBuffer in bytes.
-   */
-  promise_test(t => {
-    return createDataChannelPair()
-    .then(([channel1, channel2]) => {
-      channel1.send(helloBuffer.buffer);
-      assert_equals(channel1.bufferedAmount, helloBuffer.byteLength,
-        'Expect bufferedAmount to increase to byte length of sent buffer');
-
-      return awaitMessage(channel2)
-      .then(messageBuffer => {
-        assert_equals(channel1.bufferedAmount, 0,
-          'Expect sender bufferedAmount to be reduced after message is sent');
-      });
-    });
-  }, 'bufferedAmount should increase to byte length of buffer sent');
-
-  /*
-    6.2. send()
-      3.  Execute the sub step that corresponds to the type of the methods argument:
-          Blob object
-            Let data be the raw data represented by the Blob object and increase
-            the bufferedAmount attribute by the size of data, in bytes.
-   */
-  promise_test(t => {
-    return createDataChannelPair()
-    .then(([channel1, channel2]) => {
-      channel1.send(helloBlob);
-      assert_equals(channel1.bufferedAmount, helloBlob.size,
-        'Expect bufferedAmount to increase to size of sent blob');
-
-      return awaitMessage(channel2)
-      .then(messageBuffer => {
-        assert_equals(channel1.bufferedAmount, 0,
-          'Expect sender bufferedAmount to be reduced after message is sent');
-      });
-    });
-  }, 'bufferedAmount should increase to size of blob sent');
-
-  // Test sending 3 messages: helloBuffer, unicodeString, helloBlob
-  async_test(t => {
-    let messageCount = 0;
-
-    createDataChannelPair()
-    .then(([channel1, channel2]) => {
-      const onMessage = t.step_func(event => {
-        const { data } = event;
-        messageCount++;
-
-        if(messageCount === 3) {
-          assert_equals(channel1.bufferedAmount, 0,
-            'Expect sender bufferedAmount to be reduced after message is sent');
-
-          t.done();
-        }
-      });
-
-      channel2.addEventListener('message', onMessage);
-
-      channel1.send(helloBuffer);
-      assert_equals(channel1.bufferedAmount, helloString.length,
-        'Expect bufferedAmount to be the total length of all messages queued to send');
-
-      channel1.send(unicodeString);
-      assert_equals(channel1.bufferedAmount,
-        helloString.length + unicodeBuffer.byteLength,
-        'Expect bufferedAmount to be the total length of all messages queued to send');
-
-      channel1.send(helloBlob);
-      assert_equals(channel1.bufferedAmount,
-        helloString.length*2 + unicodeBuffer.byteLength,
-        'Expect bufferedAmount to be the total length of all messages queued to send');
-
-    }).catch(t.step_func(err =>
-      assert_unreached(`Unexpected promise rejection: ${err}`)));
-  }, 'bufferedAmount should increase by byte length for each message sent');
+
+    bufferedAmount
+      The bufferedAmount attribute must return the number of bytes of application
+      data (UTF-8 text and binary data) that have been queued using send() but that,
+      as of the last time the event loop started executing a task, had not yet been
+      transmitted to the network. (This thus includes any text sent during the
+      execution of the current task, regardless of whether the user agent is able
+      to transmit text asynchronously with script execution.) This does not include
+      framing overhead incurred by the protocol, or buffering done by the operating
+      system or network hardware. The value of the [[BufferedAmount]] slot will only
+      increase with each call to the send() method as long as the [[ReadyState]] slot
+      is open; however, the slot does not reset to zero once the channel closes. When
+      the underlying data transport sends data from its queue, the user agent MUST
+      queue a task that reduces [[BufferedAmount]] with the number of bytes that was
+      sent.
+
+
+  [WebMessaging]
+  interface MessageEvent : Event {
+    readonly attribute any data;
+    ...
+  };
+ */
+
+// Simple ASCII encoded string
+const helloString = 'hello';
+// ASCII encoded buffer representation of the string
+const helloBuffer = Uint8Array.of(0x68, 0x65, 0x6c, 0x6c, 0x6f);
+const helloBlob = new Blob([helloBuffer]);
+
+// Unicode string with multiple code units
+const unicodeString = '世界你好';
+// UTF-8 encoded buffer representation of the string
+const unicodeBuffer = Uint8Array.of(
+  0xe4, 0xb8, 0x96, 0xe7, 0x95, 0x8c,
+  0xe4, 0xbd, 0xa0, 0xe5, 0xa5, 0xbd);
+
+/*
+  Ensure .bufferedAmount is 0 initially for both sides.
+ */
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const [dc1, dc2] = await createDataChannelPair(pc1, pc2);
+
+  assert_equals(dc1.bufferedAmount, 0, 'Expect bufferedAmount to be 0');
+  assert_equals(dc2.bufferedAmount, 0, 'Expect bufferedAmount to be 0');
+}, 'bufferedAmount initial value should be 0 for both peers');
+
+/*
+  6.2.  send()
+    3.  Execute the sub step that corresponds to the type of the methods argument:
+
+        string object
+          Let data be the object and increase the bufferedAmount attribute
+          by the number of bytes needed to express data as UTF-8.
+ */
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const [dc1, dc2] = await createDataChannelPair(pc1, pc2);
+
+  dc1.send(unicodeString);
+  assert_equals(dc1.bufferedAmount, unicodeBuffer.byteLength,
+    'Expect bufferedAmount to be the byte length of the unicode string');
+
+  await awaitMessage(dc2);
+  assert_equals(dc1.bufferedAmount, 0,
+    'Expect sender bufferedAmount to be reduced after message is sent');
+}, 'bufferedAmount should increase to byte length of encoded unicode string sent');
+
+/*
+  6.2. send()
+    3.  Execute the sub step that corresponds to the type of the methods argument:
+        ArrayBuffer object
+          Let data be the data stored in the buffer described by the ArrayBuffer
+          object and increase the bufferedAmount attribute by the length of the
+          ArrayBuffer in bytes.
+ */
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const [dc1, dc2] = await createDataChannelPair(pc1, pc2);
+
+  dc1.send(helloBuffer.buffer);
+  assert_equals(dc1.bufferedAmount, helloBuffer.byteLength,
+    'Expect bufferedAmount to increase to byte length of sent buffer');
+
+  await awaitMessage(dc2);
+  assert_equals(dc1.bufferedAmount, 0,
+    'Expect sender bufferedAmount to be reduced after message is sent');
+}, 'bufferedAmount should increase to byte length of buffer sent');
+
+/*
+  6.2. send()
+    3.  Execute the sub step that corresponds to the type of the methods argument:
+        Blob object
+          Let data be the raw data represented by the Blob object and increase
+          the bufferedAmount attribute by the size of data, in bytes.
+ */
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const [dc1, dc2] = await createDataChannelPair(pc1, pc2);
+
+  dc1.send(helloBlob);
+  assert_equals(dc1.bufferedAmount, helloBlob.size,
+    'Expect bufferedAmount to increase to size of sent blob');
+
+  await awaitMessage(dc2);
+  assert_equals(dc1.bufferedAmount, 0,
+    'Expect sender bufferedAmount to be reduced after message is sent');
+}, 'bufferedAmount should increase to size of blob sent');
+
+// Test sending 3 messages: helloBuffer, unicodeString, helloBlob
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  let messageCount = 0;
+
+  const [dc1, dc2] = await createDataChannelPair(pc1, pc2);
+  const onMessage = t.step_func(() => {
+    if (++messageCount === 3) {
+      assert_equals(dc1.bufferedAmount, 0,
+        'Expect sender bufferedAmount to be reduced after message is sent');
+      resolver.resolve();
+    }
+  });
+
+  dc2.addEventListener('message', onMessage);
+
+  dc1.send(helloBuffer);
+  assert_equals(dc1.bufferedAmount, helloString.length,
+    'Expect bufferedAmount to be the total length of all messages queued to send');
+
+  dc1.send(unicodeString);
+  assert_equals(dc1.bufferedAmount,
+    helloString.length + unicodeBuffer.byteLength,
+    'Expect bufferedAmount to be the total length of all messages queued to send');
+
+  dc1.send(helloBlob);
+  assert_equals(dc1.bufferedAmount,
+    helloString.length*2 + unicodeBuffer.byteLength,
+    'Expect bufferedAmount to be the total length of all messages queued to send');
+
+  await resolver;
+}, 'bufferedAmount should increase by byte length for each message sent');
+
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const [dc1] = await createDataChannelPair(pc1, pc2);
+
+  dc1.send(helloBuffer.buffer);
+  assert_equals(dc1.bufferedAmount, helloBuffer.byteLength,
+    'Expect bufferedAmount to increase to byte length of sent buffer');
+
+  dc1.close();
+  assert_equals(dc1.bufferedAmount, helloBuffer.byteLength,
+    'Expect bufferedAmount to not decrease immediately after closing the channel');
+}, 'bufferedAmount should not decrease immediately after initiating closure');
+
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const [dc1] = await createDataChannelPair(pc1, pc2);
+
+  dc1.send(helloBuffer.buffer);
+  assert_equals(dc1.bufferedAmount, helloBuffer.byteLength,
+    'Expect bufferedAmount to increase to byte length of sent buffer');
+
+  pc1.close();
+  assert_equals(dc1.bufferedAmount, helloBuffer.byteLength,
+    'Expect bufferedAmount to not decrease after closing the peer connection');
+}, 'bufferedAmount should not decrease after closing the peer connection');
 
   promise_test(async t => {
     const [channel1, channel2] = await createDataChannelPair();
diff --git a/webrtc/RTCDataChannel-id.html b/webrtc/RTCDataChannel-id.html
index 18f70d8ce969d2..98be63d923c016 100644
--- a/webrtc/RTCDataChannel-id.html
+++ b/webrtc/RTCDataChannel-id.html
@@ -3,60 +3,340 @@
 <title>RTCDataChannel id attribute</title>
 <script src=/resources/testharness.js></script>
 <script src=/resources/testharnessreport.js></script>
+<script src="RTCPeerConnection-helper.js"></script>
 <script>
 'use strict';
 
-// This and the test below verify that after a description is set that
-// negotiates the DTLS role used by SCTP, data channels with unset IDs
-// have IDs set according to the rules in rtcweb-data-channel.
-promise_test(test => {
+// Test is based on the following revision:
+// https://rawgit.com/w3c/webrtc-pc/1cc5bfc3ff18741033d804c4a71f7891242fb5b3/webrtc.html
+
+// This is the maximum number of streams, NOT the maximum stream ID (which is 65534)
+// See: https://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-13#section-6.2
+const nStreams = 65535;
+
+/*
+  6.1.
+    21. If the [[DataChannelId]] slot is null (due to no ID being passed into
+        createDataChannel, or [[Negotiated]] being false), and the DTLS role of the SCTP
+        transport has already been negotiated, then initialize [[DataChannelId]] to a value
+        generated by the user agent, according to [RTCWEB-DATA-PROTOCOL] [...]
+ */
+promise_test(async (t) => {
   const pc = new RTCPeerConnection;
-  test.add_cleanup(() => pc.close());
-  const channel = pc.createDataChannel('');
-  return pc.createOffer()
-  .then(offer => pc.setLocalDescription(offer))
-  .then(() => {
-    // Turn our own offer SDP into valid answer SDP by setting the DTLS role to
-    // "active".
-    const answer = {
-      type: "answer",
-      sdp: pc.localDescription.sdp.replace("actpass", "active")
-    };
-    return pc.setRemoteDescription(answer);
-  })
-  .then(() => {
-    // Since the remote description had an "active" DTLS role, we're the server
-    // and should use odd data channel IDs, according to rtcweb-data-channel.
-    assert_equals(channel.id % 2, 1, 'id');
-    const another_channel = pc.createDataChannel('another');
-    assert_equals(another_channel.id % 2, 1, 'id');
-    assert_not_equals(channel.id, another_channel.id);
-  })
-}, "DTLS client uses odd data channel IDs");
-
-promise_test(test => {
+  t.add_cleanup(() => pc.close());
+
+  const dc1 = pc.createDataChannel('');
+  const ids = new UniqueSet();
+
+  const offer = await pc.createOffer();
+  await pc.setLocalDescription(offer);
+  // Turn our own offer SDP into valid answer SDP by setting the DTLS role to
+  // "active".
+  const answer = {
+    type: 'answer',
+    sdp: pc.localDescription.sdp.replace('actpass', 'active')
+  };
+  await pc.setRemoteDescription(answer);
+
+  // Since the remote description had an 'active' DTLS role, we're the server
+  // and should use odd data channel IDs, according to rtcweb-data-channel.
+  assert_equals(dc1.id % 2, 1,
+    `Channel created by the DTLS server role must be odd (was ${dc1.id})`);
+  const dc2 = pc.createDataChannel('another');
+  assert_equals(dc2.id % 2, 1,
+    `Channel created by the DTLS server role must be odd (was ${dc2.id})`);
+
+  // Ensure IDs are unique
+  ids.add(dc1.id, `Channel ID ${dc1.id} should be unique`);
+  ids.add(dc2.id, `Channel ID ${dc2.id} should be unique`);
+}, 'DTLS client uses odd data channel IDs');
+
+promise_test(async (t) => {
   const pc = new RTCPeerConnection;
-  test.add_cleanup(() => pc.close());
-  const channel = pc.createDataChannel('');
-  return pc.createOffer()
-  .then(offer => pc.setLocalDescription(offer))
-  .then(() => {
-    // Turn our own offer SDP into valid answer SDP by setting the DTLS role to
-    // "passive".
-    const answer = {
-      type: "answer",
-      sdp: pc.localDescription.sdp.replace("actpass", "passive")
-    };
-    return pc.setRemoteDescription(answer);
-  })
-  .then(() => {
-    // Since the remote description had a "passive" DTLS role, we're the client
-    // and should use even data channel IDs, according to rtcweb-data-channel.
-    assert_equals(channel.id % 2, 0, 'id');
-    const another_channel = pc.createDataChannel('another');
-    assert_equals(another_channel.id % 2, 0, 'id');
-    assert_not_equals(channel.id, another_channel.id);
-  })
-}, "DTLS server uses even data channel IDs");
+  t.add_cleanup(() => pc.close());
+
+  const dc1 = pc.createDataChannel('');
+  const ids = new UniqueSet();
+
+  const offer = await pc.createOffer();
+  await pc.setLocalDescription(offer);
+  // Turn our own offer SDP into valid answer SDP by setting the DTLS role to
+  // 'passive'.
+  const answer = {
+    type: 'answer',
+    sdp: pc.localDescription.sdp.replace('actpass', 'passive')
+  };
+  await pc.setRemoteDescription(answer);
+
+  // Since the remote description had a 'passive' DTLS role, we're the client
+  // and should use even data channel IDs, according to rtcweb-data-channel.
+  assert_equals(dc1.id % 2, 0,
+    `Channel created by the DTLS client role must be even (was ${dc1.id})`);
+  const dc2 = pc.createDataChannel('another');
+  assert_equals(dc2.id % 2, 0,
+    `Channel created by the DTLS client role must be even (was ${dc1.id})`);
+
+  // Ensure IDs are unique
+  ids.add(dc1.id, `Channel ID ${dc1.id} should be unique`);
+  ids.add(dc2.id, `Channel ID ${dc2.id} should be unique`);
+}, 'DTLS server uses even data channel IDs');
+
+/*
+  Check if the implementation allows using in-band negotiated channels with a specific ID (which
+  is now a spec violation).
+ */
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const dc1 = pc1.createDataChannel('', {
+    negotiated: false,
+    id: 42
+  });
+  dc1.onopen = t.step_func(() => {
+    dc1.send(':(');
+  });
+
+  const dc2 = pc2.createDataChannel('', {
+    negotiated: false,
+    id: 42
+  });
+  dc2.onmessage = t.step_func(() => {
+    assert_unreached('Channel established with same ID using negotiated=false');
+  });
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  // Wait a bit to ensure the 'message' event does NOT fire
+  t.step_timeout(() => resolver.resolve(), 500);
+  await resolver;
+}, 'In-band negotiation with a specific ID should not be allowed');
+
+/*
+  Check if the implementation still follows the odd/even role correctly if we annoy it with
+  negotiated channels not following that rule.
+
+  Note: This test assumes that the implementation can handle a minimum of 40 data channels.
+ */
+promise_test(async (t) => {
+  // Takes the DTLS server role
+  const pc1 = new RTCPeerConnection();
+  // Takes the DTLS client role
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  exchangeIceCandidates(pc1, pc2);
+  const dcs = [];
+  const negotiatedDcs = [];
+  const ids = new UniqueSet();
+
+  // Create 10 DCEP-negotiated channels with pc1
+  // Note: These should not have any associated valid ID at this point
+  for (let i = 0; i < 10; ++i) {
+    const dc = pc1.createDataChannel('before-connection');
+    assert_equals(dc.id, null, 'Channel id must be null before DTLS role has been determined');
+    dcs.push(dc);
+  }
+
+  // Create 10 negotiated channels with pc1 violating the odd/even rule
+  for (let id = 0; id < 20; id += 2) {
+    const dc = pc1.createDataChannel(`negotiated-not-odd-${id}-before-connection`, {
+      negotiated: true,
+      id: id,
+    });
+    assert_equals(dc.id, null, 'Channel id must be null before DTLS role has been determined');
+    negotiatedDcs.push([dc, id]);
+    ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
+  }
+
+  await doSignalingHandshake(pc1, pc2, {
+    offer: (offer) => {
+      // Ensure pc1 takes the server role
+      assert_true(offer.sdp.includes('actpass') || offer.sdp.includes('passive'),
+        'pc1 must take the DTLS server role');
+      return offer;
+    },
+    answer: (answer) => {
+      // Ensure pc2 takes the client role
+      // Note: It very likely will choose 'active' itself
+      answer.sdp = answer.sdp.replace('actpass', 'active');
+      assert_true(answer.sdp.includes('active'), 'pc2 must take the DTLS client role');
+      return answer;
+    },
+  });
+
+  for (const dc of dcs) {
+    assert_equals(dc.id % 2, 1,
+      `Channel created by the DTLS server role must be odd (was ${dc.id})`);
+    ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
+  }
+
+  // Create 10 channels with pc1
+  for (let i = 0; i < 10; ++i) {
+    const dc = pc1.createDataChannel('after-connection');
+    assert_equals(dc.id % 2, 1,
+      `Channel created by the DTLS server role must be odd (was ${dc.id})`);
+    dcs.push(dc);
+    ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
+  }
+
+  // Create 10 negotiated channels with pc1 violating the odd/even rule
+  for (let i = 0; i < 10; ++i) {
+    // Generate a valid even ID that has not been taken, yet.
+    let id = 20;
+    while (ids.has(id)) {
+      id += 2;
+    }
+    const dc = pc1.createDataChannel(`negotiated-not-odd-${i}-after-connection`, {
+      negotiated: true,
+      id: id,
+    });
+    negotiatedDcs.push([dc, id]);
+    ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
+  }
+
+  // Since we've added new channels, let's check again that the odd/even role is not violated
+  for (const dc of dcs) {
+    assert_equals(dc.id % 2, 1,
+      `Channel created by the DTLS server role must be odd (was ${dc.id})`);
+  }
+
+  // Let's also make sure the negotiated channels have kept their ID
+  for (const [dc, id] of negotiatedDcs) {
+    assert_equals(dc.id, id, 'Negotiated channels should keep their assigned ID');
+  }
+}, 'Odd/even role should not be violated when mixing with negotiated channels');
+
+/*
+  Create 32768 (client), 32767 (server) channels to make sure all ids are exhausted AFTER
+  establishing a peer connection.
+
+  6.1.  createDataChannel
+    21. If the [[DataChannelId]] slot is null (due to no ID being passed into
+        createDataChannel, or [[Negotiated]] being false), and the DTLS role of the SCTP
+        transport has already been negotiated, then initialize [[DataChannelId]] to a value
+        generated by the user agent, according to [RTCWEB-DATA-PROTOCOL], and skip
+        to the next step. If no available ID could be generated, or if the value of the
+        [[DataChannelId]] slot is being used by an existing RTCDataChannel, throw an
+        OperationError exception.
+ */
+/*
+ TODO: Improve test coverage for RTCSctpTransport.maxChannels.
+ TODO: Improve test coverage for exhausting channel cases.
+ */
+
+/*
+  Create 32768 (client), 32767 (server) channels to make sure all ids are exhausted BEFORE
+  establishing a peer connection.
+
+  Be aware that late channel id assignment can currently fail in many places not covered by the
+  spec, see: https://github.com/w3c/webrtc-pc/issues/1818
+
+  4.4.1.6.
+    2.2.6.  If description negotiates the DTLS role of the SCTP transport, and there is an
+            RTCDataChannel with a null id, then generate an ID according to [RTCWEB-DATA-PROTOCOL].
+            If no available ID could be generated, then run the following steps:
+      1.    Let channel be the RTCDataChannel object for which an ID could not be generated.
+      2.    Set channel's [[ReadyState]] slot to "closed".
+      3.    Fire an event named error with an OperationError exception at channel.
+      4.    Fire a simple event named close at channel.
+ */
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  // Takes the DTLS server role
+  const pc1 = new RTCPeerConnection();
+  // Takes the DTLS client role
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  exchangeIceCandidates(pc1, pc2);
+  const dcs = [];
+  const ids = new UniqueSet();
+  let nExpected = 0;
+  let nActualCloses = 0;
+  let nActualErrors = 0;
+
+  const maybeDone = t.step_func(() => {
+    if (nExpected === nActualCloses && nExpected === nActualErrors) {
+      resolver.resolve();
+    }
+  });
+
+  // Create 65535+2 channels (since 65535 streams is a SHOULD, we may have less than that.)
+  // Create two extra channels to possibly trigger the steps in the description.
+  //
+  // Note: Following the spec strictly would assume that this cannot fail. But in reality it will
+  //       fail because the implementation knows how many streams it supports. What it doesn't
+  //       know is how many streams the other peer supports (e.g. what will be negotiated).
+  for (let i = 0; i < (nStreams + 2); ++i) {
+    let dc;
+    try {
+      const pc = i % 2 === 1 ? pc1 : pc2;
+      dc = pc.createDataChannel('this is going to be fun');
+      dc.onclose = t.step_func(() => {
+        ++nActualCloses;
+        maybeDone();
+      });
+      dc.onerror = t.step_func((e) => {
+        assert_true(e instanceof RTCError, 'Expect error object to be instance of RTCError');
+        assert_equals(e.error, 'sctp-failure', "Expect error to be of type 'sctp-failure'");
+        ++nActualErrors;
+        maybeDone();
+      });
+    } catch (e) {
+      assert_equals(e.name, 'OperationError', 'Fail on creation should throw OperationError');
+      break;
+    }
+    assert_equals(dc.id, null, 'Channel id must be null before DTLS role has been determined');
+    assert_not_equals(dc.readyState, 'closed',
+      'Channel may not be closed before connection establishment');
+    dcs.push([dc, i % 2 === 1]);
+  }
+
+  await doSignalingHandshake(pc1, pc2, {
+    offer: (offer) => {
+      // Ensure pc1 takes the server role
+      assert_true(offer.sdp.includes('actpass') || offer.sdp.includes('passive'),
+        'pc1 must take the DTLS server role');
+      return offer;
+    },
+    answer: (answer) => {
+      // Ensure pc2 takes the client role
+      // Note: It very likely will choose 'active' itself
+      answer.sdp = answer.sdp.replace('actpass', 'active');
+      assert_true(answer.sdp.includes('active'), 'pc2 must take the DTLS client role');
+      return answer;
+    },
+  });
+
+  // Since the spec does not define a specific order to which channels may fail if an ID could
+  // not be generated, any of the channels may be affected by the steps of the description.
+  for (const [dc, odd] of dcs) {
+    if (dc.readyState !== 'closed') {
+      assert_equals(dc.id % 2, odd ? 1 : 0,
+        `Channels created by the DTLS ${odd ? 'server' : 'client'} role must be
+        ${odd ? 'odd' : 'even'} (was ${dc.id})`);
+      ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
+    } else {
+      ++nExpected;
+    }
+  }
+
+  // Try creating one further channel on both sides. The attempt should fail since all IDs are
+  // taken. If one ID is available, the implementation probably miscounts (or I did in the test).
+  assert_throws('OperationError', () =>
+    pc1.createDataChannel('this is too exhausting!'));
+  assert_throws('OperationError', () =>
+    pc2.createDataChannel('this is too exhausting!'));
+
+  maybeDone();
+  await resolver;
+}, 'Channel ID exhaustion handling (before and after connection establishment)');
 
 </script>
diff --git a/webrtc/RTCDataChannelEvent-constructor.html b/webrtc/RTCDataChannelEvent-constructor.html
index 997f65c43801a9..03211eccb920e1 100644
--- a/webrtc/RTCDataChannelEvent-constructor.html
+++ b/webrtc/RTCDataChannelEvent-constructor.html
@@ -4,6 +4,9 @@
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script>
+// Test is based on the following revision:
+// https://rawgit.com/w3c/webrtc-pc/1cc5bfc3ff18741033d804c4a71f7891242fb5b3/webrtc.html
+
 test(function() {
     assert_equals(RTCDataChannelEvent.length, 2);
     assert_throws(
@@ -26,11 +29,13 @@
     );
 }, 'RTCDataChannelEvent constructor with a channel passed as undefined.');
 
-test(function() {
-    var pc = new RTCPeerConnection();
-    var c = pc.createDataChannel('');
-    var e = new RTCDataChannelEvent('type', { channel: c });
-    assert_true(e instanceof RTCDataChannelEvent);
-    assert_equals(e.channel, c);
+test(t => {
+    const pc = new RTCPeerConnection();
+    t.add_cleanup(() => pc.close());
+
+    const dc = pc.createDataChannel('');
+    const event = new RTCDataChannelEvent('type', { channel: dc });
+    assert_true(event instanceof RTCDataChannelEvent);
+    assert_equals(event.channel, dc);
 }, 'RTCDataChannelEvent constructor with full arguments.');
 </script>
diff --git a/webrtc/RTCPeerConnection-createDataChannel.html b/webrtc/RTCPeerConnection-createDataChannel.html
index 450a25002ed221..ae74b62d42c3de 100644
--- a/webrtc/RTCPeerConnection-createDataChannel.html
+++ b/webrtc/RTCPeerConnection-createDataChannel.html
@@ -3,44 +3,51 @@
 <title>RTCPeerConnection.prototype.createDataChannel</title>
 <script src=/resources/testharness.js></script>
 <script src=/resources/testharnessreport.js></script>
+<script src="RTCPeerConnection-helper.js"></script>
 <script>
 'use strict';
 
-// Test is based on the following editor draft:
-// https://rawgit.com/w3c/webrtc-pc/cc8d80f455b86c8041d63bceb8b457f45c72aa89/webrtc.html
+// Test is based on the following revision:
+// https://rawgit.com/w3c/webrtc-pc/1cc5bfc3ff18741033d804c4a71f7891242fb5b3/webrtc.html
 
 /*
   6.1.  RTCPeerConnection Interface Extensions
 
     partial interface RTCPeerConnection {
-      RTCDataChannel createDataChannel(USVString label,
-                                        optional RTCDataChannelInit dataChannelDict);
-      ...
+        [...]
+        RTCDataChannel createDataChannel(USVString label,
+                                         optional RTCDataChannelInit dataChannelDict);
+        [...]
     };
 
   6.2.  RTCDataChannel
 
     interface RTCDataChannel : EventTarget {
-       readonly attribute USVString           label;
-       readonly attribute boolean             ordered;
-       readonly attribute unsigned short?     maxPacketLifeTime;
-       readonly attribute unsigned short?     maxRetransmits;
-       readonly attribute USVString           protocol;
-       readonly attribute boolean             negotiated;
-       readonly attribute unsigned short?     id;
-       readonly attribute RTCPriorityType     priority;
-       readonly attribute RTCDataChannelState readyState;
+        readonly attribute USVString           label;
+        readonly attribute boolean             ordered;
+        readonly attribute unsigned short?     maxPacketLifeTime;
+        readonly attribute unsigned short?     maxRetransmits;
+        readonly attribute USVString           protocol;
+        readonly attribute boolean             negotiated;
+        readonly attribute unsigned short?     id;
+        readonly attribute RTCPriorityType     priority;
+        readonly attribute RTCDataChannelState readyState;
+        readonly attribute unsigned long       bufferedAmount;
+                 attribute unsigned long       bufferedAmountLowThreshold;
+        [...]
+                 attribute DOMString           binaryType;
+        [...]
     };
 
     dictionary RTCDataChannelInit {
-      boolean         ordered = true;
-      unsigned short  maxPacketLifeTime;
-      unsigned short  maxRetransmits;
-      USVString       protocol = "";
-      boolean         negotiated = false;
-      [EnforceRange]
-      unsigned short  id;
-      RTCPriorityType priority = "low";
+        boolean         ordered = true;
+        unsigned short  maxPacketLifeTime;
+        unsigned short  maxRetransmits;
+        USVString       protocol = "";
+        boolean         negotiated = false;
+        [EnforceRange]
+        unsigned short  id;
+        RTCPriorityType priority = "low";
     };
 
   4.9.1.  RTCPriorityType Enum
@@ -53,8 +60,10 @@
     };
  */
 
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
   assert_equals(pc.createDataChannel.length, 1);
   assert_throws(new TypeError(), () => pc.createDataChannel());
 }, 'createDataChannel with no argument should throw TypeError');
@@ -63,7 +72,7 @@
   6.2.  createDataChannel
     2.  If connection's [[isClosed]] slot is true, throw an InvalidStateError.
  */
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
   pc.close();
   assert_equals(pc.signalingState, 'closed', 'signaling state');
@@ -72,57 +81,81 @@
 
 /*
   6.1.  createDataChannel
-    4.  Let channel have a [[Label]] internal slot initialized to the value of the
+    4.  Let channel have a [[DataChannelLabel]] internal slot initialized to the value of the
         first argument.
-    5.  Let options be the second argument.
-    6.  Let channel have an [[MaxPacketLifeTime]] internal slot initialized to
+    6.  Let options be the second argument.
+    7.  Let channel have an [[MaxPacketLifeTime]] internal slot initialized to
         option's maxPacketLifeTime member, if present, otherwise null.
-    7.  Let channel have an [[MaxRetransmits]] internal slot initialized to
+    8.  Let channel have a [[ReadyState]] internal slot initialized to "connecting".
+    9.  Let channel have a [[BufferedAmount]] internal slot initialized to 0.
+    10. Let channel have an [[MaxRetransmits]] internal slot initialized to
         option's maxRetransmits member, if present, otherwise null.
-    8.  Let channel have an [[DataChannelId]] internal slot initialized to
-        option's id member, if present, otherwise null.
-    9.  Let channel have an [[Ordered]] internal slot initialized to option's
+    11. Let channel have an [[Ordered]] internal slot initialized to option's
         ordered member.
-    10. Let channel have an [[Protocol]] internal slot initialized to option's
+    12. Let channel have a [[DataChannelProtocol]] internal slot initialized to option's
         protocol member.
-    11. Let channel have an [[Negotiated]] internal slot initialized to option's
-        negotiated member.
-    12. Let channel have an [[DataChannelPriority]] internal slot initialized
-        to option's priority member.
+    14. Let channel have a [[Negotiated]] internal slot initialized to option's negotiated
+        member.
+    15. Let channel have an [[DataChannelId]] internal slot initialized to option's id
+        member, if it is present and [[Negotiated]] is true, otherwise null.
+    17. Let channel have an [[DataChannelPriority]] internal slot initialized to option's
+        priority member.
+    21. If the [[DataChannelId]] slot is null (due to no ID being passed into
+        createDataChannel, or [[Negotiated]] being false), and the DTLS role of the SCTP
+        transport has already been negotiated, then initialize [[DataChannelId]] to a value
+        generated by the user agent, according to [RTCWEB-DATA-PROTOCOL], and skip
+        to the next step. If no available ID could be generated, or if the value of the
+        [[DataChannelId]] slot is being used by an existing RTCDataChannel, throw an
+        OperationError exception.
+
+        Note
+        If the [[DataChannelId]] slot is null after this step, it will be populated once
+        the DTLS role is determined during the process of setting an RTCSessionDescription.
+    22. If channel is the first RTCDataChannel created on connection, update the
+        negotiation-needed flag for connection.
+
 
   6.2.  RTCDataChannel
 
     A RTCDataChannel, created with createDataChannel or dispatched via a
     RTCDataChannelEvent, MUST initially be in the connecting state
 
+    bufferedAmountLowThreshold
+      [...] The bufferedAmountLowThreshold is initially zero on each new RTCDataChannel,
+      but the application may change its value at any time.
+
     binaryType
-      When a RTCDataChannel object is created, the binaryType attribute MUST
+      [...] When a RTCDataChannel object is created, the binaryType attribute MUST
       be initialized to the string "blob".
  */
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
-  const channel = pc.createDataChannel('');
-  assert_true(channel instanceof RTCDataChannel, 'is RTCDataChannel');
-  assert_equals(channel.label, '');
-  assert_equals(channel.ordered, true);
-  assert_equals(channel.maxPacketLifeTime, null);
-  assert_equals(channel.maxRetransmits, null);
-  assert_equals(channel.protocol, '');
-  assert_equals(channel.negotiated, false);
+  t.add_cleanup(() => pc.close());
+
+  const dc = pc.createDataChannel('');
 
+  assert_true(dc instanceof RTCDataChannel, 'is RTCDataChannel');
+  assert_equals(dc.label, '');
+  assert_equals(dc.ordered, true);
+  assert_equals(dc.maxPacketLifeTime, null);
+  assert_equals(dc.maxRetransmits, null);
+  assert_equals(dc.protocol, '');
+  assert_equals(dc.negotiated, false);
   // Since no offer/answer exchange has occurred yet, the DTLS role is unknown
   // and so the ID should be null.
-  assert_equals(channel.id, null);
-  assert_equals(channel.priority, 'low');
-
-  assert_equals(channel.readyState, 'connecting');
-  assert_equals(channel.binaryType, 'blob');
-
+  assert_equals(dc.id, null);
+  assert_equals(dc.priority, 'low');
+  assert_equals(dc.readyState, 'connecting');
+  assert_equals(dc.bufferedAmount, 0);
+  assert_equals(dc.bufferedAmountLowThreshold, 0);
+  assert_equals(dc.binaryType, 'blob');
 }, 'createDataChannel attribute default values');
 
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
-  const channel = pc.createDataChannel('test', {
+  t.add_cleanup(() => pc.close());
+
+  const dc = pc.createDataChannel('test', {
     ordered: false,
     maxPacketLifeTime: null,
     maxRetransmits: 1,
@@ -132,23 +165,24 @@
     priority: 'high'
   });
 
-  assert_true(channel instanceof RTCDataChannel, 'is RTCDataChannel');
-  assert_equals(channel.label, 'test');
-  assert_equals(channel.ordered, false);
-  assert_equals(channel.maxPacketLifeTime, null);
-  assert_equals(channel.maxRetransmits, 1);
-  assert_equals(channel.protocol, 'custom');
-  assert_equals(channel.negotiated, true);
-  assert_equals(channel.id, 3);
-  assert_equals(channel.priority, 'high');
-  assert_equals(channel.readyState, 'connecting');
-  assert_equals(channel.binaryType, 'blob');
-
+  assert_true(dc instanceof RTCDataChannel, 'is RTCDataChannel');
+  assert_equals(dc.label, 'test');
+  assert_equals(dc.ordered, false);
+  assert_equals(dc.maxPacketLifeTime, null);
+  assert_equals(dc.maxRetransmits, 1);
+  assert_equals(dc.protocol, 'custom');
+  assert_equals(dc.negotiated, true);
+  assert_equals(dc.id, 3);
+  assert_equals(dc.priority, 'high');
+  assert_equals(dc.readyState, 'connecting');
+  assert_equals(dc.bufferedAmount, 0);
+  assert_equals(dc.bufferedAmountLowThreshold, 0);
+  assert_equals(dc.binaryType, 'blob');
 }, 'createDataChannel with provided parameters should initialize attributes to provided values');
 
 /*
   6.2.  createDataChannel
-    4.  Let channel have a [[Label]] internal slot initialized to the value of the
+    4.  Let channel have a [[DataChannelLabel]] internal slot initialized to the value of the
         first argument.
 
   [ECMA262] 7.1.12. ToString(argument)
@@ -164,76 +198,102 @@
   ['lone surrogate', '\uD800', '\uFFFD'],
 ];
 for (const [description, label, expected] of labels) {
-  test(() => {
+  test((t) => {
     const pc = new RTCPeerConnection;
-    const channel = pc.createDataChannel(label);
-    assert_equals(channel.label, expected);
+    t.add_cleanup(() => pc.close());
+
+    const dc = pc.createDataChannel(label);
+    assert_equals(dc.label, expected);
   }, `createDataChannel with label ${description} should succeed`);
 }
 
 /*
   6.2.  RTCDataChannel
     createDataChannel
-      9.  Let channel have an [[Ordered]] internal slot initialized to option's
+      11. Let channel have an [[Ordered]] internal slot initialized to option's
           ordered member.
  */
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
-  const channel = pc.createDataChannel('', { ordered: false });
-  assert_equals(channel.ordered, false);
+  t.add_cleanup(() => pc.close());
+
+  const dc = pc.createDataChannel('', { ordered: false });
+  assert_equals(dc.ordered, false);
 }, 'createDataChannel with ordered false should succeed');
 
 // true as the default value of a boolean is confusing because null is converted
 // to false while undefined is converted to true.
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
-  const channel1 = pc.createDataChannel('', { ordered: null });
-  assert_equals(channel1.ordered, false);
-  const channel2 = pc.createDataChannel('', { ordered: undefined });
-  assert_equals(channel2.ordered, true);
+  t.add_cleanup(() => pc.close());
+
+  const dc1 = pc.createDataChannel('', { ordered: null });
+  assert_equals(dc1.ordered, false);
+  const dc2 = pc.createDataChannel('', { ordered: undefined });
+  assert_equals(dc2.ordered, true);
 }, 'createDataChannel with ordered null/undefined should succeed');
 
 /*
   6.2.  RTCDataChannel
     createDataChannel
-      6.  Let channel have an [[MaxPacketLifeTime]] internal slot initialized to
+      7.  Let channel have an [[MaxPacketLifeTime]] internal slot initialized to
           option's maxPacketLifeTime member, if present, otherwise null.
  */
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection;
-  const channel = pc.createDataChannel('', { maxPacketLifeTime: 0 });
-  assert_equals(channel.maxPacketLifeTime, 0);
+  t.add_cleanup(() => pc.close());
+
+  const dc = pc.createDataChannel('', { maxPacketLifeTime: 0 });
+  assert_equals(dc.maxPacketLifeTime, 0);
 }, 'createDataChannel with maxPacketLifeTime 0 should succeed');
 
 /*
   6.2.  RTCDataChannel
     createDataChannel
-      7.  Let channel have an [[MaxRetransmits]] internal slot initialized to
+      10. Let channel have an [[MaxRetransmits]] internal slot initialized to
           option's maxRetransmits member, if present, otherwise null.
  */
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection;
-  const channel = pc.createDataChannel('', { maxRetransmits: 0 });
-  assert_equals(channel.maxRetransmits, 0);
+  t.add_cleanup(() => pc.close());
+
+  const dc = pc.createDataChannel('', { maxRetransmits: 0 });
+  assert_equals(dc.maxRetransmits, 0);
 }, 'createDataChannel with maxRetransmits 0 should succeed');
 
 /*
   6.2.  createDataChannel
-    15. If both [[MaxPacketLifeTime]] and [[MaxRetransmits]] attributes are set
-        (not null), throw a TypeError.
+    18. If both [[MaxPacketLifeTime]] and [[MaxRetransmits]] attributes are set (not null),
+        throw a TypeError.
  */
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection;
+  t.add_cleanup(() => pc.close());
+
+  pc.createDataChannel('', {
+    maxPacketLifeTime: null,
+    maxRetransmits: null
+  });
+}, 'createDataChannel with both maxPacketLifeTime and maxRetransmits null should succeed');
+
+test((t) => {
+  const pc = new RTCPeerConnection;
+  t.add_cleanup(() => pc.close());
+
   assert_throws(new TypeError(), () => pc.createDataChannel('', {
     maxPacketLifeTime: 0,
     maxRetransmits: 0
   }));
-}, 'createDataChannel with both maxPacketLifeTime and maxRetransmits should throw SyntaxError');
+  assert_throws(new TypeError(), () => pc.createDataChannel('', {
+    maxPacketLifeTime: 42,
+    maxRetransmits: 42
+  }));
+}, 'createDataChannel with both maxPacketLifeTime and maxRetransmits should throw TypeError');
 
 /*
   6.2.  RTCDataChannel
     createDataChannel
-      10. Let channel have an [[Protocol]] internal slot initialized to option's
+      12. Let channel have a [[DataChannelProtocol]] internal slot initialized to option's
           protocol member.
  */
 const protocols = [
@@ -243,43 +303,36 @@
   ['lone surrogate', '\uD800', '\uFFFD'],
 ];
 for (const [description, protocol, expected] of protocols) {
-  test(() => {
+  test((t) => {
     const pc = new RTCPeerConnection;
-    const channel = pc.createDataChannel('', { protocol });
-    assert_equals(channel.protocol, expected);
+    t.add_cleanup(() => pc.close());
+
+    const dc = pc.createDataChannel('', { protocol });
+    assert_equals(dc.protocol, expected);
   }, `createDataChannel with protocol ${description} should succeed`);
 }
 
 /*
   6.2.  RTCDataChannel
     createDataChannel
-      11. Let channel have an [[Negotiated]] internal slot initialized to option's
-          negotiated member.
- */
-test(() => {
-  const pc = new RTCPeerConnection;
-  const channel = pc.createDataChannel('', { negotiated: true });
-  assert_equals(channel.negotiated, true);
-}, 'createDataChannel with negotiated true should succeed');
-
-
-/*
-  6.2.  RTCDataChannel
-    createDataChannel
-      10. If id is equal to 65535, which is greater than the maximum allowed ID
-          of 65534 but still qualifies as an unsigned short, throw a TypeError.
+      20. If [[DataChannelId]] is equal to 65535, which is greater than the maximum allowed
+          ID of 65534 but still qualifies as an unsigned short, throw a TypeError.
  */
 for (const id of [0, 1, 65534]) {
-  test(() => {
+  test((t) => {
     const pc = new RTCPeerConnection();
-    const channel = pc.createDataChannel('', { id });
-    assert_equals(channel.id, id);
+    t.add_cleanup(() => pc.close());
+
+    const dc = pc.createDataChannel('', { id });
+    assert_equals(dc.id, id);
   }, `createDataChannel with id ${id} should succeed`);
 }
 
 for (const id of [-1, 65535, 65536]) {
-  test(() => {
+  test((t) => {
     const pc = new RTCPeerConnection();
+    t.add_cleanup(() => pc.close());
+
     assert_throws(new TypeError(), () => pc.createDataChannel('', { id }));
   }, `createDataChannel with id ${id} should throw TypeError`);
 }
@@ -287,152 +340,383 @@
 /*
   6.2.  RTCDataChannel
     createDataChannel
-      12. Let channel have an [[DataChannelPriority]] internal slot initialized
-          to option's priority member.
-
+      17. Let channel have an [[DataChannelPriority]] internal slot initialized to option's
+          priority member.
  */
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
-  const channel = pc.createDataChannel('', { priority: 'high' });
-  assert_equals(channel.priority, 'high');
+  t.add_cleanup(() => pc.close());
+
+  const dc = pc.createDataChannel('', { priority: 'high' });
+  assert_equals(dc.priority, 'high');
 }, 'createDataChannel with priority "high" should succeed');
 
-test(() => {
+test((t) => {
   const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
   assert_throws(new TypeError(),
     () => pc.createDataChannel('', { priority: 'invalid' }));
 }, 'createDataChannel with invalid priority should throw TypeError');
 
 /*
   6.2.  createDataChannel
-    13. If [[Negotiated]] is false and [[Label]] is longer than 65535 bytes
-        long, throw a TypeError.  */
-test(() => {
+    5.  If [[DataChannelLabel]] is longer than 65535 bytes, throw a TypeError.
+ */
+test((t) => {
   const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
   assert_throws(new TypeError(), () =>
-    pc.createDataChannel('', {
-      label: ' '.repeat(65536),
-      negotiated: false
+    pc.createDataChannel('l'.repeat(65536)));
+
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('l'.repeat(65536), {
+      negotiated: true,
+      id: 42
     }));
-}, 'createDataChannel with negotiated false and long label should throw TypeError');
+}, 'createDataChannel with too long label should throw TypeError');
+
+test((t) => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('\u00b5'.repeat(32768)));
+
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('\u00b5'.repeat(32768), {
+      negotiated: true,
+      id: 42
+    }));
+}, 'createDataChannel with too long label (2 byte unicode) should throw TypeError');
+
+/*
+  6.2.  label
+        [...] Scripts are allowed to create multiple RTCDataChannel objects with the same label.
+        [...]
+ */
+test(t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
+  const label = 'test';
+
+  pc.createDataChannel(label);
+  pc.createDataChannel(label);
+}, 'createDataChannel with same label used twice should not throw');
 
 /*
   6.2.  createDataChannel
-    14. If [[Negotiated]] is false and [[Protocol]] is longer than 65535 bytes long,
-        throw a TypeError.
+    13. If [[DataChannelProtocol]] is longer than 65535 bytes long, throw a TypeError.
  */
+
 test(() => {
+  const pc = new RTCPeerConnection;
+  const channel = pc.createDataChannel('', { negotiated: true });
+  assert_equals(channel.negotiated, true);
+}, 'createDataChannel with negotiated true should succeed');
+
+test((t) => {
   const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
   assert_throws(new TypeError(), () =>
     pc.createDataChannel('', {
-      protocol: ' '.repeat(65536),
-      negotiated: false
+      protocol: 'p'.repeat(65536)
     }));
-}, 'createDataChannel with negotiated false and long protocol should throw TypeError');
 
-test(() => {
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('', {
+      protocol: 'p'.repeat(65536),
+      negotiated: true,
+      id: 42
+    }));
+}, 'createDataChannel with too long protocol should throw TypeError');
+
+test((t) => {
   const pc = new RTCPeerConnection();
-  const label = ' '.repeat(65536)
+  t.add_cleanup(() => pc.close());
+
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('', {
+      protocol: '\u00b6'.repeat(32768)
+    }));
+
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('', {
+      protocol: '\u00b6'.repeat(32768),
+      negotiated: true,
+      id: 42
+    }));
+}, 'createDataChannel with too long protocol (2 byte unicode) should throw TypeError');
+
+test((t) => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
+  const label = 'l'.repeat(65535);
+  const protocol = 'p'.repeat(65535);
+
+  const dc = pc.createDataChannel(label, {
+    protocol: protocol
+  });
+
+  assert_equals(dc.label, label);
+  assert_equals(dc.protocol, protocol);
+}, 'createDataChannel with maximum length label and protocol should succeed');
 
-  const channel = pc.createDataChannel('', {
-    label,
-    protocol: ' '.repeat(65536),
-    negotiated: true
+/*
+  6.2   createDataChannel
+    15. Let channel have an [[DataChannelId]] internal slot initialized to option's id member,
+        if it is present and [[Negotiated]] is true, otherwise null.
+
+        NOTE
+        This means the id member will be ignored if the data channel is negotiated in-band; this
+        is intentional. Data channels negotiated in-band should have IDs selected based on the
+        DTLS role, as specified in [RTCWEB-DATA-PROTOCOL].
+ */
+test((t) => {
+  const pc = new RTCPeerConnection;
+  t.add_cleanup(() => pc.close());
+
+  const dc = pc.createDataChannel('', {
+    negotiated: false,
   });
+  assert_equals(dc.negotiated, false, 'Expect dc.negotiated to be false');
+}, 'createDataChannel with negotiated false should succeed');
+
+test((t) => {
+  const pc = new RTCPeerConnection;
+  t.add_cleanup(() => pc.close());
 
-  assert_equals(channel.label, label);
-}, 'createDataChannel with negotiated true and long label and long protocol should succeed');
+  const dc = pc.createDataChannel('', {
+    negotiated: false,
+    id: 42
+  });
+  assert_equals(dc.negotiated, false, 'Expect dc.negotiated to be false');
+  assert_equals(dc.id, null, 'Expect dc.id to be ignored (null)');
+}, 'createDataChannel with negotiated false and id 42 should ignore the id');
+
+/*
+  6.2.  createDataChannel
+    16. If [[Negotiated]] is true and [[DataChannelId]] is null, throw a TypeError.
+ */
+test((t) => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('test', {
+      negotiated: true
+    }));
+}, 'createDataChannel with negotiated true and id not defined should throw TypeError');
+
+test((t) => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
+  assert_throws(new TypeError(), () =>
+    pc.createDataChannel('test', {
+      negotiated: true,
+      id: null
+    }));
+}, 'createDataChannel with negotiated true and id null should throw TypeError');
 
 /*
   4.4.1.6.  Set the RTCSessionSessionDescription
     2.2.6.  If description is of type "answer" or "pranswer", then run the
             following steps:
-      1.  If description initiates the establishment of a new SCTP association,
-          as defined in [SCTP-SDP], Sections 10.3 and 10.4, set the value of
-          connection's [[sctpTransport]] internal slot to a newly created RTCSctpTransport.
-      2.  If description negotiates the DTLS role of the SCTP transport, and
-          there is an RTCDataChannel with a null id, then generate an ID according
-          to [RTCWEB-DATA-PROTOCOL].
+      3.    If description negotiates the DTLS role of the SCTP transport, and there is an
+            RTCDataChannel with a null id, then generate an ID according to
+            [RTCWEB-DATA-PROTOCOL]. [...]
 
-  6.2.  createDataChannel
-    18. If the [[DataChannelId]] slot is null (due to no ID being passed into
-        createDataChannel), and the DTLS role of the SCTP transport has already
-        been negotiated, then initialize [[DataChannelId]] to a value generated
-        by the user agent, according to [RTCWEB-DATA-PROTOCOL].
+  6.1.  createDataChannel
+    21. If the [[DataChannelId]] slot is null (due to no ID being passed into
+        createDataChannel, or [[Negotiated]] being false), and the DTLS role of the SCTP
+        transport has already been negotiated, then initialize [[DataChannelId]] to a value
+        generated by the user agent, according to [RTCWEB-DATA-PROTOCOL], and skip
+        to the next step. If no available ID could be generated, or if the value of the
+        [[DataChannelId]] slot is being used by an existing RTCDataChannel, throw an
+        OperationError exception.
+
+        Note
+        If the [[DataChannelId]] slot is null after this step, it will be populated once
+        the DTLS role is determined during the process of setting an RTCSessionDescription.
  */
-promise_test(t => {
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const negotiatedDc = pc1.createDataChannel('negotiated-channel', {
+    negotiated: true,
+    id: 42,
+  });
+  assert_equals(negotiatedDc.id, 42, 'Expect negotiatedDc.id to be 42');
+
+  const dc1 = pc1.createDataChannel('channel');
+  assert_equals(dc1.id, null, 'Expect initial id to be null');
+
+  const offer = await pc1.createOffer();
+  await Promise.all([pc1.setLocalDescription(offer), pc2.setRemoteDescription(offer)]);
+  const answer = await pc2.createAnswer();
+  await pc1.setRemoteDescription(answer);
+
+  assert_not_equals(dc1.id, null,
+    'Expect dc1.id to be assigned after remote description has been set');
+
+  assert_greater_than_equal(dc1.id, 0,
+    'Expect dc1.id to be set to valid unsigned short');
+
+  assert_less_than(dc1.id, 65535,
+    'Expect dc1.id to be set to valid unsigned short');
+
+  const dc2 = pc1.createDataChannel('channel');
+
+  assert_not_equals(dc2.id, null,
+    'Expect dc2.id to be assigned after remote description has been set');
+
+  assert_greater_than_equal(dc2.id, 0,
+    'Expect dc2.id to be set to valid unsigned short');
+
+  assert_less_than(dc2.id, 65535,
+    'Expect dc2.id to be set to valid unsigned short');
+
+  assert_not_equals(dc2, dc1,
+    'Expect channels created from same label to be different');
+
+  assert_equals(dc2.label, dc1.label,
+    'Expect different channels can have the same label but different id');
+
+  assert_not_equals(dc2.id, dc1.id,
+    'Expect different channels can have the same label but different id');
+
+  assert_equals(negotiatedDc.id, 42,
+    'Expect negotiatedDc.id to be 42 after remote description has been set');
+}, 'Channels created (after setRemoteDescription) should have id assigned');
+
+test((t) => {
   const pc = new RTCPeerConnection();
   t.add_cleanup(() => pc.close());
-  const channel1 = pc.createDataChannel('channel');
-  assert_equals(channel1.id, null,
-    'Expect initial id to be null');
 
-  return pc.createOffer()
-  .then(offer =>
-    pc.setLocalDescription(offer)
-    .then(() => generateAnswer(offer)))
-  .then(answer => pc.setRemoteDescription(answer))
-  .then(() => {
-    assert_not_equals(channel1.id, null,
-      'Expect channel1.id to be assigned');
+  const dc1 = pc.createDataChannel('channel-1', {
+    negotiated: true,
+    id: 42,
+  });
+  assert_equals(dc1.id, 42,
+    'Expect dc1.id to be 42');
 
-    assert_greater_than_equal(channel1.id, 0,
-      'Expect channel1.id to be set to valid unsigned short');
+  const dc2 = pc.createDataChannel('channel-2', {
+    negotiated: true,
+    id: 43,
+  });
+  assert_equals(dc2.id, 43,
+    'Expect dc2.id to be 43');
 
-    assert_less_than(channel1.id, 65535,
-      'Expect channel1.id to be set to valid unsigned short');
+  assert_throws('OperationError', () =>
+    pc.createDataChannel('channel-3', {
+      negotiated: true,
+      id: 42,
+    }));
 
-    const channel2 = pc.createDataChannel('channel');
+}, 'Reusing a data channel id that is in use should throw OperationError');
 
-    assert_not_equals(channel2.id, null,
-      'Expect channel2.id to be assigned');
+// We've seen implementations behaving differently before and after the connection has been
+// established.
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
 
-    assert_greater_than_equal(channel2.id, 0,
-      'Expect channel2.id to be set to valid unsigned short');
+  const dc1 = pc1.createDataChannel('channel-1', {
+    negotiated: true,
+    id: 42,
+  });
+  assert_equals(dc1.id, 42, 'Expect dc1.id to be 42');
 
-    assert_less_than(channel2.id, 65535,
-      'Expect channel2.id to be set to valid unsigned short');
+  const dc2 = pc1.createDataChannel('channel-2', {
+    negotiated: true,
+    id: 43,
+  });
+  assert_equals(dc2.id, 43, 'Expect dc2.id to be 43');
 
-    assert_not_equals(channel2, channel1,
-      'Expect channels created from same label to be different');
+  const offer = await pc1.createOffer();
+  await Promise.all([pc1.setLocalDescription(offer), pc2.setRemoteDescription(offer)]);
+  const answer = await pc2.createAnswer();
+  await pc1.setRemoteDescription(answer);
 
-    assert_equals(channel2.label, channel1.label,
-      'Expect different channnels can have the same label but different id');
+  assert_equals(dc1.id, 42, 'Expect dc1.id to be 42');
 
-    assert_not_equals(channel2.id, channel1.id,
-      'Expect different channnels can have the same label but different id');
-  });
-}, 'Channels created after SCTP transport is established should have id assigned');
+  assert_equals(dc2.id, 43, 'Expect dc2.id to be 43');
 
-/*
-  TODO
-    6.1.  createDataChannel
-      18. If no available ID could be generated, or if the value of the
-          id member of the dictionary is taken by an existing RTCDataChannel, throw
-          a ResourceInUse exception.
+  assert_throws('OperationError', () =>
+    pc1.createDataChannel('channel-3', {
+      negotiated: true,
+      id: 42,
+    }));
+}, 'Reusing a data channel id that is in use (after setRemoteDescription) should throw ' +
+   'OperationError');
+
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
 
+  const dc1 = pc1.createDataChannel('channel-1');
+
+  const offer = await pc1.createOffer();
+  await Promise.all([pc1.setLocalDescription(offer), pc2.setRemoteDescription(offer)]);
+  const answer = await pc2.createAnswer();
+  await pc1.setRemoteDescription(answer);
+
+  assert_not_equals(dc1.id, null,
+    'Expect dc1.id to be assigned after remote description has been set');
+
+  assert_throws('OperationError', () =>
+    pc1.createDataChannel('channel-2', {
+      negotiated: true,
+      id: dc1.id,
+    }));
+}, 'Reusing a data channel id that is in use (after setRemoteDescription, negotiated via DCEP) ' +
+  'should throw OperationError');
+
+// Based on https://bugzilla.mozilla.org/show_bug.cgi?id=1441723
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  await createDataChannelPair(pc1, pc2);
+
+  const dc = pc1.createDataChannel('');
+  assert_equals(dc.readyState, 'connecting', 'Channel should be in the connecting state');
+}, 'New data channel should be in the connecting state after creation (after connection ' +
+  'establishment)');
+
+/*
   Untestable
     6.1.  createDataChannel
-      16. If a setting, either [[MaxPacketLifeTime]] or [[MaxRetransmits]], has
-          been set to indicate unreliable mode, and that value exceeds the maximum
-          value supported by the user agent, the value MUST be set to the user
-          agents maximum value.
+      19. If a setting, either [[MaxPacketLifeTime]] or [[MaxRetransmits]], has been set to
+          indicate unreliable mode, and that value exceeds the maximum value supported
+          by the user agent, the value MUST be set to the user agents maximum value.
 
-      20. Create channel's associated underlying data transport and configure
+      23. Return channel and continue the following steps in parallel.
+      24. Create channel's associated underlying data transport and configure
           it according to the relevant properties of channel.
 
   Tested in RTCPeerConnection-onnegotiationneeded.html
-    21. If channel was the first RTCDataChannel created on connection, update
-        the negotiation-needed flag for connection.
-
-  Issues
-    w3c/webrtc-pc#1412
-      ResourceInUse exception is not defined
-
-  Coverage Report
-    Tested        22
-    Not Tested     1
-    Untestable     2
-    Total         25
+    22. If channel is the first RTCDataChannel created on connection, update the
+        negotiation-needed flag for connection.
+
+  Tested in RTCDataChannel-id.html
+    - Odd/even rules for '.id'
+
+  Tested in RTCDataChannel-dcep.html
+    - Transmission of '.label' and further options
 */
 </script>
diff --git a/webrtc/RTCPeerConnection-helper.js b/webrtc/RTCPeerConnection-helper.js
index 0b25df26190c14..310f028c605cbf 100644
--- a/webrtc/RTCPeerConnection-helper.js
+++ b/webrtc/RTCPeerConnection-helper.js
@@ -261,51 +261,93 @@ function listenForSSRCs(t, receiver) {
 // end points to open.
 function createDataChannelPair(
   pc1=new RTCPeerConnection(),
-  pc2=new RTCPeerConnection())
+  pc2=new RTCPeerConnection(),
+  options={})
 {
-  const channel1 = pc1.createDataChannel('');
+  options = Object.assign({}, {
+    channelLabel: '',
+    channelOptions: undefined,
+    doSignaling: true
+  }, options);
+
+  let channel1Options;
+  let channel2Options = null;
+  if (options.channelOptions instanceof Array) {
+    [channel1Options, channel2Options] = options.channelOptions;
+  } else {
+    channel1Options = options.channelOptions;
+  }
 
-  exchangeIceCandidates(pc1, pc2);
+  const channel1 = pc1.createDataChannel(options.channelLabel, channel1Options);
 
   return new Promise((resolve, reject) => {
     let channel2;
     let opened1 = false;
     let opened2 = false;
 
+    function cleanup() {
+      channel1.removeEventListener('open', onOpen1);
+      channel2.removeEventListener('open', onOpen2);
+      channel1.removeEventListener('error', onError);
+      channel2.removeEventListener('error', onError);
+    }
+
     function onBothOpened() {
+      cleanup();
       resolve([channel1, channel2]);
     }
 
+    function onError(...args) {
+      cleanup();
+      reject(...args);
+    }
+
     function onOpen1() {
       opened1 = true;
-      if(opened2) onBothOpened();
+      if (opened2) {
+        onBothOpened();
+      }
     }
 
     function onOpen2() {
       opened2 = true;
-      if(opened1) onBothOpened();
+      if (opened1) {
+        onBothOpened();
+      }
     }
 
-    function onDataChannel(event) {
-      channel2 = event.channel;
-      channel2.addEventListener('error', reject);
+    function onDataChannelPairFound() {
+      channel2.addEventListener('error', onError, { once: true });
       const { readyState } = channel2;
 
-      if(readyState === 'open') {
+      if (readyState === 'open') {
         onOpen2();
-      } else if(readyState === 'connecting') {
-        channel2.addEventListener('open', onOpen2);
+      } else if (readyState === 'connecting') {
+        channel2.addEventListener('open', onOpen2, { once: true });
       } else {
-        reject(new Error(`Unexpected ready state ${readyState}`));
+        onError(new Error(`Unexpected ready state ${readyState}`));
       }
     }
 
-    channel1.addEventListener('open', onOpen1);
-    channel1.addEventListener('error', reject);
+    function onDataChannel(event) {
+      channel2 = event.channel;
+      onDataChannelPairFound();
+    }
+
+    channel1.addEventListener('open', onOpen1, { once: true });
+    channel1.addEventListener('error', onError, { once: true });
 
-    pc2.addEventListener('datachannel', onDataChannel);
+    if (channel2Options !== null) {
+      channel2 = pc2.createDataChannel(options.channelLabel, channel2Options);
+      onDataChannelPairFound();
+    } else {
+      pc2.addEventListener('datachannel', onDataChannel);
+    }
 
-    doSignalingHandshake(pc1, pc2);
+    if (options.doSignaling) {
+      exchangeIceCandidates(pc1, pc2);
+      doSignalingHandshake(pc1, pc2, options);
+    }
   });
 }
 
diff --git a/webrtc/RTCPeerConnection-ondatachannel.html b/webrtc/RTCPeerConnection-ondatachannel.html
index 1070ee701d2336..711027439b3ab4 100644
--- a/webrtc/RTCPeerConnection-ondatachannel.html
+++ b/webrtc/RTCPeerConnection-ondatachannel.html
@@ -5,180 +5,376 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="RTCPeerConnection-helper.js"></script>
 <script>
-  'use strict';
-
-  // Test is based on the following editor draft:
-  // https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
-
-  // The following helper functions are called from RTCPeerConnection-helper.js:
-  // exchangeIceCandidates
-  // doSignalingHandshake
-
-  /*
-    6.2.  RTCDataChannel
-      When an underlying data transport is to be announced
-        2.  Let channel be a newly created RTCDataChannel object.
-        5.  Set channel's readyState attribute to connecting.
-        6.  Fire a datachannel event named datachannel with channel at the
-            RTCPeerConnection object.
-
-    6.3.  RTCDataChannelEvent
-      Firing a datachannel event named e with a RTCDataChannel channel means
-      that an event with the name e, which does not bubble (except where
-      otherwise stated) and is not cancelable (except where otherwise stated),
-      and which uses the RTCDataChannelEvent interface with the channel
-      attribute set to channel, must be created and dispatched at the given
-      target.
-
-      interface RTCDataChannelEvent : Event {
-        readonly attribute RTCDataChannel channel;
-      };
-   */
-  async_test(t => {
-    const localPc = new RTCPeerConnection();
-    t.add_cleanup(() => localPc.close());
-    const remotePc = new RTCPeerConnection();
-
-    t.add_cleanup(() => remotePc.close());
-
-    let eventCount = 0;
-
-    const onDataChannel = t.step_func_done(event => {
-      eventCount++;
-      assert_equals(eventCount, 1,
-        'Expect data channel event to fire exactly once');
-
-      assert_true(event instanceof RTCDataChannelEvent,
-        'Expect event to be instance of RTCDataChannelEvent');
-
-      assert_equals(event.bubbles, false);
-      assert_equals(event.cancelable, false);
-
-      const { channel } = event;
-      assert_true(channel instanceof RTCDataChannel,
-        'Expect channel to be instance of RTCDataChannel');
-
-      const { readyState } = channel;
-
-      // The spec requires readyState to be connecting at first,
-      // but it may quickly change to open before the callback
-      // is invoked, especially with local connections.
-      assert_true(readyState === 'connecting' || readyState === 'open',
-        'Expect channel ready state to be either connecting or open');
-    });
+'use strict';
+
+// Test is based on the following revision:
+// https://rawgit.com/w3c/webrtc-pc/1cc5bfc3ff18741033d804c4a71f7891242fb5b3/webrtc.html
+
+// The following helper functions are called from RTCPeerConnection-helper.js:
+// exchangeIceCandidates
+// doSignalingHandshake
+// createDataChannelPair
+
+/*
+  6.2.  RTCDataChannel
+    When an underlying data transport is to be announced (the other peer created a channel with
+    negotiated unset or set to false), the user agent of the peer that did not initiate the
+    creation process MUST queue a task to run the following steps:
+      2. Let channel be a newly created RTCDataChannel object.
+      7. Set channel's [[ReadyState]] to open (but do not fire the open event, yet).
+      8. Fire a datachannel event named datachannel with channel at the RTCPeerConnection object.
+
+  6.3.  RTCDataChannelEvent
+    Firing a datachannel event named e with an RTCDataChannel channel means that an event with the
+    name e, which does not bubble (except where otherwise stated) and is not cancelable (except
+    where otherwise stated), and which uses the RTCDataChannelEvent interface with the channel
+    attribute set to channel, MUST be created and dispatched at the given target.
+
+    interface RTCDataChannelEvent : Event {
+      readonly attribute RTCDataChannel channel;
+    };
+ */
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  let eventCount = 0;
+
+  pc2.ondatachannel = t.step_func((event) => {
+    eventCount++;
+    assert_equals(eventCount, 1,
+      'Expect data channel event to fire exactly once');
+
+    assert_true(event instanceof RTCDataChannelEvent,
+      'Expect event to be instance of RTCDataChannelEvent');
+
+    assert_equals(event.bubbles, false);
+    assert_equals(event.cancelable, false);
+
+    const dc = event.channel;
+    assert_true(dc instanceof RTCDataChannel,
+      'Expect channel to be instance of RTCDataChannel');
+
+    // The channel should be in the 'open' state already.
+    // See: https://github.com/w3c/webrtc-pc/pull/1851
+    assert_equals(dc.readyState, 'open',
+      'Expect channel ready state to be open');
+
+    resolver.resolve();
+  });
+
+  pc1.createDataChannel('fire-me!');
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  await resolver;
+}, 'Data channel event should fire when new data channel is announced to the remote peer');
+
+/*
+  Since the channel should be in the 'open' state when dispatching via the 'datachannel' event,
+  we should be able to send data in the event handler.
+ */
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
 
-    localPc.createDataChannel('test');
-
-    remotePc.addEventListener('datachannel', onDataChannel);
-    exchangeIceCandidates(localPc, remotePc);
-    doSignalingHandshake(localPc, remotePc);
-  }, 'datachannel event should fire when new data channel is announced to the remote peer');
-
-  /*
-    6.2.  RTCDataChannel
-      interface RTCDataChannel : EventTarget {
-        readonly attribute USVString           label;
-        readonly attribute boolean             ordered;
-        readonly attribute unsigned short?     maxPacketLifeTime;
-        readonly attribute unsigned short?     maxRetransmits;
-        readonly attribute USVString           protocol;
-        readonly attribute boolean             negotiated;
-        readonly attribute unsigned short?     id;
-        readonly attribute RTCPriorityType     priority;
-        readonly attribute RTCDataChannelState readyState;
-        ...
-      };
-
-      When an underlying data transport is to be announced
-        3.  Let configuration be an information bundle received from the
-            other peer as a part of the process to establish the underlying
-            data transport described by the WebRTC DataChannel Protocol
-            specification [RTCWEB-DATA-PROTOCOL].
-        4.  Initialize channel's label, ordered, maxPacketLifeTime,
-            maxRetransmits, protocol, negotiated and id attributes to their
-            corresponding values in configuration.
-   */
-  async_test(t => {
-    const localPc = new RTCPeerConnection();
-    t.add_cleanup(() => localPc.close());
-    const remotePc = new RTCPeerConnection();
-
-    t.add_cleanup(() => remotePc.close());
-
-    const onDataChannel = t.step_func_done(event => {
-      const remoteChannel = event.channel;
-      assert_true(remoteChannel instanceof RTCDataChannel,
-        'Expect channel to be instance of RTCDataChannel');
-
-      assert_equals(remoteChannel.label, 'test');
-      assert_equals(remoteChannel.id, 8);
-      assert_equals(remoteChannel.ordered, false);
-      assert_equals(remoteChannel.maxRetransmits, 1);
-      assert_equals(remoteChannel.protocol, 'custom');
-      assert_equals(remoteChannel.priority, 'high');
+  const message = 'meow meow!';
+
+  pc2.ondatachannel = t.step_func((event) => {
+    const dc2 = event.channel;
+    dc2.send(message);
+  });
+
+  const dc1 = pc1.createDataChannel('fire-me!');
+  dc1.onmessage = t.step_func((event) => {
+    assert_equals(event.data, message,
+      'Received data should be equal to sent data');
+
+    resolver.resolve();
+  });
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  await resolver;
+}, 'Should be able to send data in a datachannel event handler');
+
+/*
+  6.2.  RTCDataChannel
+    When an underlying data transport is to be announced (the other peer created a channel with
+    negotiated unset or set to false), the user agent of the peer that did not initiate the
+    creation process MUST queue a task to run the following steps:
+      8. Fire a datachannel event named datachannel with channel at the RTCPeerConnection object.
+      9. If the channel's [[ReadyState]] is still open, announce the data channel as open.
+ */
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  pc2.ondatachannel = t.step_func((event) => {
+    const dc = event.channel;
+    dc.onopen = t.step_func(() => {
+      assert_unreached('Open event should not fire');
     });
 
-    const localChannel = localPc.createDataChannel('test', {
-      id: 8,
-      ordered: false,
-      maxRetransmits: 1,
-      protocol: 'custom',
-      priority: 'high'
+    // This should prevent triggering the 'open' event
+    dc.close();
+
+    // Wait a bit to ensure the 'open' event does NOT fire
+    t.step_timeout(() => resolver.resolve(), 500);
+  });
+
+  pc1.createDataChannel('fire-me!');
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  await resolver;
+}, 'Open event should not be raised when closing the channel in the datachannel event');
+
+// Added this test as a result of the discussion in
+// https://github.com/w3c/webrtc-pc/pull/1851#discussion_r185976747
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  pc2.ondatachannel = t.step_func((event) => {
+    const dc = event.channel;
+    dc.onopen = t.step_func((event) => {
+      resolver.resolve();
     });
 
-    assert_equals(localChannel.label, 'test');
-    assert_equals(localChannel.id, 8);
-    assert_equals(localChannel.ordered, false);
-    assert_equals(localChannel.maxRetransmits, 1);
-    assert_equals(localChannel.protocol, 'custom');
-    assert_equals(localChannel.priority, 'high');
-
-    remotePc.addEventListener('datachannel', onDataChannel);
-    exchangeIceCandidates(localPc, remotePc);
-    doSignalingHandshake(localPc, remotePc);
-  }, 'Data channel created on remote peer should match the same configuration as local peer');
-
-  /*
-    6.2.  RTCDataChannel
-      Dictionary RTCDataChannelInit Members
-        negotiated
-          The default value of false tells the user agent to announce the
-          channel in-band and instruct the other peer to dispatch a corresponding
-          RTCDataChannel object. If set to true, it is up to the application
-          to negotiate the channel and create a RTCDataChannel object with the
-          same id at the other peer.
-   */
-  async_test(t => {
-    const localPc = new RTCPeerConnection();
-    t.add_cleanup(() => localPc.close());
-    const remotePc = new RTCPeerConnection();
-
-    t.add_cleanup(() => remotePc.close());
-
-    const onDataChannel = t.unreached_func('datachannel event should not be fired');
-
-    localPc.createDataChannel('test', {
-      negotiated: true
+    // This should NOT prevent triggering the 'open' event since it enqueues at least two tasks
+    t.step_timeout(() => {
+      t.step_timeout(() => {
+        dc.close()
+      }, 1);
+    }, 1);
+  });
+
+  pc1.createDataChannel('fire-me!');
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  await resolver;
+}, 'Open event should be raised when closing the channel in the datachannel event after ' +
+  'enqueuing a task');
+
+
+/*
+  Combination of the two tests above (send and close).
+ */
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const message = 'meow meow!';
+
+  pc2.ondatachannel = t.step_func((event) => {
+    const dc2 = event.channel;
+    dc2.onopen = t.step_func(() => {
+      assert_unreached('Open event should not fire');
     });
 
-    remotePc.addEventListener('datachannel', onDataChannel);
-    exchangeIceCandidates(localPc, remotePc);
-    doSignalingHandshake(localPc, remotePc);
-
-    t.step_timeout(t.step_func_done(), 200);
-  }, 'Data channel created with negotiated set to true should not fire datachannel event on remote peer');
-
-  /*
-    Non-testable
-    6.2.  RTCDataChannel
-      When an underlying data transport is to be announced
-        1.  If the associated RTCPeerConnection object's [[isClosed]] slot
-            is true, abort these steps.
-
-    The above step is not testable because to reach it we would have to
-    close the peer connection after the remote peer call
-    setLocalDescription(answer) but before the underlying data transport
-    is connected. This require the promise callback for setLocalDescription()
-    to be called at the right moment, which is not always possible.
-   */
+    // This should send but still prevent triggering the 'open' event
+    dc2.send(message);
+    dc2.close();
+  });
+
+  const dc1 = pc1.createDataChannel('fire-me!');
+  dc1.onmessage = t.step_func((event) => {
+    assert_equals(event.data, message,
+      'Received data should be equal to sent data');
+
+    resolver.resolve();
+  });
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  await resolver;
+}, 'Open event should not be raised when sending and immediately closing the channel in the ' +
+  'datachannel event');
+
+/*
+  6.2.  RTCDataChannel
+
+    interface RTCDataChannel : EventTarget {
+      readonly attribute USVString           label;
+      readonly attribute boolean             ordered;
+      readonly attribute unsigned short?     maxPacketLifeTime;
+      readonly attribute unsigned short?     maxRetransmits;
+      readonly attribute USVString           protocol;
+      readonly attribute boolean             negotiated;
+      readonly attribute unsigned short?     id;
+      readonly attribute RTCPriorityType     priority;
+      readonly attribute RTCDataChannelState readyState;
+      ...
+    };
+
+    When an underlying data transport is to be announced (the other peer created a channel with
+    negotiated unset or set to false), the user agent of the peer that did not initiate the
+    creation process MUST queue a task to run the following steps:
+      2. Let channel be a newly created RTCDataChannel object.
+      3. Let configuration be an information bundle received from the other peer as a part of the
+         process to establish the underlying data transport described by the WebRTC DataChannel
+         Protocol specification [RTCWEB-DATA-PROTOCOL].
+      4. Initialize channel's [[DataChannelLabel]], [[Ordered]], [[MaxPacketLifeTime]],
+         [[MaxRetransmits]], [[DataChannelProtocol]], and [[DataChannelId]] internal slots to the
+         corresponding values in configuration.
+      5. Initialize channel's [[Negotiated]] internal slot to false.
+      6. Initialize channel's [[DataChannelPriority]] internal slot based on the integer priority
+         value in configuration, [...]
+      7. Set channel's [[ReadyState]] slot to connecting.
+      8. Fire a datachannel event named datachannel with channel at the RTCPeerConnection object.
+
+    Note: More exhaustive tests are defined in RTCDataChannel-dcep
+ */
+
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const dc1 = pc1.createDataChannel('test', {
+    ordered: false,
+    maxRetransmits: 1,
+    protocol: 'custom',
+    priority: 'high'
+  });
+
+  assert_equals(dc1.label, 'test');
+  assert_equals(dc1.ordered, false);
+  assert_equals(dc1.maxPacketLifeTime, null);
+  assert_equals(dc1.maxRetransmits, 1);
+  assert_equals(dc1.protocol, 'custom');
+  assert_equals(dc1.negotiated, false);
+  assert_equals(dc1.priority, 'high');
+
+  pc2.ondatachannel = t.step_func((event) => {
+    const dc2 = event.channel;
+    assert_true(dc2 instanceof RTCDataChannel,
+      'Expect channel to be instance of RTCDataChannel');
+
+    assert_equals(dc2.label, 'test');
+    assert_equals(dc2.ordered, false);
+    assert_equals(dc2.maxPacketLifeTime, null);
+    assert_equals(dc2.maxRetransmits, 1);
+    assert_equals(dc2.protocol, 'custom');
+    assert_equals(dc2.negotiated, false);
+    assert_equals(dc2.id, dc1.id);
+    assert_equals(dc2.priority, 'high');
+
+    resolver.resolve();
+  });
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  await resolver;
+}, 'In-band negotiated channel created on remote peer should match the same configuration as local ' +
+  'peer');
+
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  const dc1 = pc1.createDataChannel('');
+
+  assert_equals(dc1.label, '');
+  assert_equals(dc1.ordered, true);
+  assert_equals(dc1.maxPacketLifeTime, null);
+  assert_equals(dc1.maxRetransmits, null);
+  assert_equals(dc1.protocol, '');
+  assert_equals(dc1.negotiated, false);
+  assert_equals(dc1.priority, 'low');
+
+  pc2.ondatachannel = t.step_func((event) => {
+    const dc2 = event.channel;
+    assert_true(dc2 instanceof RTCDataChannel,
+      'Expect channel to be instance of RTCDataChannel');
+
+    assert_equals(dc2.label, '');
+    assert_equals(dc2.ordered, true);
+    assert_equals(dc2.maxPacketLifeTime, null);
+    assert_equals(dc2.maxRetransmits, null);
+    assert_equals(dc2.protocol, '');
+    assert_equals(dc2.negotiated, false);
+    assert_equals(dc2.id, dc1.id);
+    assert_equals(dc2.priority, 'low');
+
+    resolver.resolve();
+  });
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  await resolver;
+}, 'In-band negotiated channel created on remote peer should match the same (default) ' +
+  'configuration as local peer');
+
+/*
+  6.2.  RTCDataChannel
+    Dictionary RTCDataChannelInit Members
+      negotiated
+        The default value of false tells the user agent to announce the
+        channel in-band and instruct the other peer to dispatch a corresponding
+        RTCDataChannel object. If set to true, it is up to the application
+        to negotiate the channel and create a RTCDataChannel object with the
+        same id at the other peer.
+ */
+promise_test(async (t) => {
+  const resolver = new Resolver();
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  pc2.ondatachannel = t.unreached_func('datachannel event should not be fired');
+
+  pc1.createDataChannel('test', {
+    negotiated: true
+  });
+
+  exchangeIceCandidates(pc1, pc2);
+  await doSignalingHandshake(pc1, pc2);
+
+  // Wait a bit to ensure the 'datachannel' event does NOT fire
+  t.step_timeout(() => resolver.resolve(), 500);
+  await resolver;
+}, 'Negotiated channel should not fire datachannel event on remote peer');
+
+/*
+  Non-testable
+  6.2.  RTCDataChannel
+    When an underlying data transport is to be announced
+      1.  If the associated RTCPeerConnection object's [[isClosed]] slot
+          is true, abort these steps.
+
+  The above step is not testable because to reach it we would have to
+  close the peer connection just between receiving the in-band negotiated data
+  channel via DCEP and firing the datachannel event.
+ */
 </script>
diff --git a/webrtc/RTCSctpTransport-constructor.html b/webrtc/RTCSctpTransport-constructor.html
index 28dae055532490..e837d9b127b909 100644
--- a/webrtc/RTCSctpTransport-constructor.html
+++ b/webrtc/RTCSctpTransport-constructor.html
@@ -5,85 +5,121 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="RTCPeerConnection-helper.js"></script>
 <script>
-  'use strict';
-
-  // Test is based on the following editor draft:
-  // https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
-
-  // The following helper functions are called from RTCPeerConnection-helper.js:
-  //   generateDataChannelOffer()
-  //   generateAnswer()
-
-  /*
-    6.1.  RTCPeerConnection Interface Extensions
-      partial interface RTCPeerConnection {
-        readonly attribute RTCSctpTransport? sctp;
-        ...
-      };
-
-      1.1.  RTCSctpTransport Interface
-        interface RTCSctpTransport {
-          readonly attribute RTCDtlsTransport transport;
-          readonly attribute unsigned long    maxMessageSize;
-        };
-
-    4.4.1.1.  Constructor
-      8.  Let connection have an [[sctpTransport]] internal slot, initialized to null.
-
-    4.3.1.6.  Set the RTCSessionSessionDescription
-      2.2.6.  If description is of type "answer" or "pranswer", then run the
-              following steps:
-        1.  If description initiates the establishment of a new SCTP association,
-            as defined in [SCTP-SDP], Sections 10.3 and 10.4, set the value of
-            connection's [[SctpTransport]] internal slot to a newly created
-            RTCSctpTransport.
-   */
-
-  promise_test(t => {
-    const pc = new RTCPeerConnection();
-    t.add_cleanup(() => pc.close());
-    assert_equals(pc.sctp, null);
-    pc.createDataChannel('test');
-
-    return pc.createOffer()
-    .then(offer =>
-      pc.setLocalDescription(offer)
-      .then(() => generateAnswer(offer)))
-    .then(answer => pc.setRemoteDescription(answer))
-    .then(() => {
-      const { sctp } = pc;
-      assert_not_equals(sctp, null);
-      assert_true(sctp instanceof RTCSctpTransport,
-        'Expect pc.sctp to be instance of RTCSctpTransport');
-
-      assert_true(sctp.transport instanceof RTCDtlsTransport,
-        'Expect sctp.transport to be instance of RTCDtlsTransport');
-
-      assert_true(typeof sctp.maxMessageSize == 'number',
-        'Expect sctp.maxMessageSize to be a number');
-    });
-  }, 'setRemoteDescription() with answer containing data media should initialize pc.sctp');
-
-  promise_test(t => {
-    const pc = new RTCPeerConnection();
-    t.add_cleanup(() => pc.close());
-    assert_equals(pc.sctp, null);
-
-    return generateDataChannelOffer(pc)
-    .then(offer => pc.setRemoteDescription(offer))
-    .then(() => pc.createAnswer())
-    .then(answer => pc.setLocalDescription(answer))
-    .then(() => {
-      const { sctp } = pc;
-      assert_not_equals(sctp, null);
-      assert_true(sctp instanceof RTCSctpTransport,
-        'Expect pc.sctp to be instance of RTCSctpTransport');
-
-      assert_true(sctp.transport instanceof RTCDtlsTransport,
-        'Expect sctp.transport to be instance of RTCDtlsTransport');
-
-      assert_true(typeof sctp.maxMessageSize == 'number',
-        'Expect sctp.maxMessageSize to be a number');
-    });
-  }, 'setLocalDescription() with answer containing data media should initialize pc.sctp');
+'use strict';
+
+// Test is based on the following revision:
+// https://rawgit.com/w3c/webrtc-pc/1cc5bfc3ff18741033d804c4a71f7891242fb5b3/webrtc.html
+
+// The following helper functions are called from RTCPeerConnection-helper.js:
+//   generateDataChannelOffer()
+//   generateAnswer()
+
+/*
+  6.1.
+
+    partial interface RTCPeerConnection {
+      readonly attribute RTCSctpTransport? sctp;
+      ...
+    };
+
+  6.1.1.
+
+    interface RTCSctpTransport {
+        readonly attribute RTCDtlsTransport      transport;
+        readonly attribute RTCSctpTransportState state;
+        readonly attribute unrestricted double   maxMessageSize;
+                 attribute EventHandler          onstatechange;
+    };
+
+  4.4.1.1.  Constructor
+    9.      Let connection have an [[SctpTransport]] internal slot, initialized to null.
+
+  4.4.1.6.  Set the RTCSessionSessionDescription
+    2.2.6.  If description is of type "answer" or "pranswer", then run the
+            following steps:
+      1.    If description initiates the establishment of a new SCTP association, as defined in
+            [SCTP-SDP], Sections 10.3 and 10.4, create an RTCSctpTransport with an initial state
+            of "connecting" and assign the result to the [[SctpTransport]] slot.
+ */
+
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  assert_equals(pc1.sctp, null, 'RTCSctpTransport must be null');
+
+  const offer = await generateOffer({ pc: pc1, audio: true });
+  await Promise.all([pc1.setLocalDescription(offer), pc2.setRemoteDescription(offer)]);
+  const answer = await pc2.createAnswer();
+  await pc1.setRemoteDescription(answer);
+
+  assert_equals(pc1.sctp, null, 'RTCSctpTransport must remain null');
+}, 'setRemoteDescription() with answer not containing data media should not initialize pc.sctp');
+
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  assert_equals(pc1.sctp, null, 'RTCSctpTransport must be null');
+
+  const offer = await generateOffer({ pc: pc2, audio: true });
+  await Promise.all([pc2.setLocalDescription(offer), pc1.setRemoteDescription(offer)]);
+  const answer = await pc1.createAnswer();
+  await pc1.setLocalDescription(answer);
+
+  assert_equals(pc1.sctp, null, 'RTCSctpTransport must remain null');
+}, 'setLocalDescription() with answer not containing data media should not initialize pc.sctp');
+
+function validateSctpTransport(sctp) {
+  assert_not_equals(sctp, null, 'RTCSctpTransport must be available');
+
+  assert_true(sctp instanceof RTCSctpTransport,
+    'Expect pc.sctp to be instance of RTCSctpTransport');
+
+  assert_true(sctp.transport instanceof RTCDtlsTransport,
+    'Expect sctp.transport to be instance of RTCDtlsTransport');
+
+  assert_equals(sctp.state, 'connecting', 'RTCSctpTransport should be in the connecting state');
+
+  // Note: Yes, Number.POSITIVE_INFINITY is also a 'number'
+  assert_true(typeof sctp.maxMessageSize === 'number',
+    'Expect sctp.maxMessageSize to be a number');
+}
+
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  assert_equals(pc1.sctp, null, 'RTCSctpTransport must be null');
+
+  const offer = await generateDataChannelOffer(pc1);
+  await Promise.all([pc1.setLocalDescription(offer), pc2.setRemoteDescription(offer)]);
+  const answer = await pc2.createAnswer();
+  await pc1.setRemoteDescription(answer);
+
+  validateSctpTransport(pc1.sctp);
+}, 'setRemoteDescription() with answer containing data media should initialize pc.sctp');
+
+promise_test(async (t) => {
+  const pc1 = new RTCPeerConnection();
+  const pc2 = new RTCPeerConnection();
+  t.add_cleanup(() => pc1.close());
+  t.add_cleanup(() => pc2.close());
+
+  assert_equals(pc1.sctp, null, 'RTCSctpTransport must be null');
+
+  const offer = await generateDataChannelOffer(pc2);
+  await Promise.all([pc2.setLocalDescription(offer), pc1.setRemoteDescription(offer)]);
+  const answer = await pc1.createAnswer();
+  await pc1.setLocalDescription(answer);
+
+  validateSctpTransport(pc1.sctp);
+}, 'setLocalDescription() with answer containing data media should initialize pc.sctp');
+
 </script>
diff --git a/webrtc/RTCSctpTransport-maxMessageSize.html b/webrtc/RTCSctpTransport-maxMessageSize.html
index 9163a66af151e3..99767611509197 100644
--- a/webrtc/RTCSctpTransport-maxMessageSize.html
+++ b/webrtc/RTCSctpTransport-maxMessageSize.html
@@ -9,10 +9,13 @@
 'use strict';
 
 // This test has an assert_unreached() that requires that the variable
-// canSendSize (initiated below) is greater than 2, if non-zero. The reason
-// is that we need two non-zero values that are less that that value for
-// testing with predictable results. This is a bit unfortunate but shouldn't
-// have any practical impact.
+// canSendSize (initiated below) must be 0 or greater than 2. The reason
+// is that we need two non-zero values for testing the following two cases:
+//
+// * if remote MMS `1` < canSendSize it should result in `1`.
+// * renegotiation of the above case with remoteMMS `2` should result in `2`.
+//
+// This is a bit unfortunate but shouldn't have any practical impact.
 
 // Helper class to read SDP attributes and generate SDPs with modified attribute values
 class SDPAttributeHelper {
@@ -39,148 +42,165 @@
 }
 
 const mmsAttributeHelper = new SDPAttributeHelper('max-message-size', '\\d+');
-let canSendSize;
-const remoteValue1 = 1;
-const remoteValue2 = 2;
+let canSendSize = null;
+const remoteSize1 = 1;
+const remoteSize2 = 2;
 
-promise_test(t => {
+promise_test(async (t) => {
   const pc = new RTCPeerConnection();
   t.add_cleanup(() => pc.close());
-  assert_equals(pc.sctp, null);
-  let maxMessageSize;
-
-  return generateDataChannelOffer(pc)
-  .then((offer) => {
-    assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
-      'SDP should have max-message-size attribute');
-
-    offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, 0) };
-    return pc.setRemoteDescription(offer);
-  })
-  .then(() => pc.createAnswer())
-  .then((answer) => pc.setLocalDescription(answer))
-  .then(() => {
-    assert_not_equals(pc.sctp, null);
-    canSendSize = pc.sctp.maxMessageSize == Number.POSITIVE_INFINITY ? 0 : pc.sctp.maxMessageSize;
-    if (canSendSize != 0 && canSendSize < remoteValue2) {
-      assert_unreached('This test needs two values that are less than canSendSize (unless it is zero)');
-    }
-  });
+
+  assert_equals(pc.sctp, null, 'RTCSctpTransport must be null');
+
+  let offer = await generateDataChannelOffer(pc);
+  assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
+    'SDP should have max-message-size attribute');
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, 0) };
+  await pc.setRemoteDescription(offer);
+  const answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  canSendSize = pc.sctp.maxMessageSize === Number.POSITIVE_INFINITY ? 0 : pc.sctp.maxMessageSize;
+  if (canSendSize !== 0 && canSendSize < remoteSize2) {
+    assert_unreached(
+      'This test needs canSendSize to be 0 or > 2 for further "below" and "above" tests');
+  }
 }, 'Determine the local side send limitation (canSendSize) by offering a max-message-size of 0');
 
-promise_test(t => {
+promise_test(async (t) => {
+  assert_not_equals(canSendSize, null, 'canSendSize needs to be determined');
+
   const pc = new RTCPeerConnection();
   t.add_cleanup(() => pc.close());
-  assert_equals(pc.sctp, null);
-
-  return generateDataChannelOffer(pc)
-  .then((offer) => {
-    assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
-      'SDP should have max-message-size attribute');
-
-    // Remove the max-message-size SDP attribute
-    offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithoutAttribute(offer.sdp) };
-    return pc.setRemoteDescription(offer)
-  })
-  .then(() => pc.createAnswer())
-  .then((answer) => pc.setLocalDescription(answer))
-  .then(() => {
-    assert_not_equals(pc.sctp, null);
-    // Test outcome depends on canSendSize value
-    if (canSendSize) {
-      assert_equals(pc.sctp.maxMessageSize, Math.min(65536, canSendSize),
-        'Missing SDP attribute and a non-zero canSendSize should give an maxMessageSize of min(65536, canSendSize)');
-    } else {
-      assert_equals(pc.sctp.maxMessageSize, 65536,
-        'Missing SDP attribute and a canSendSize of 0 should give an maxMessageSize of 65536');
-    }
-  });
+
+  assert_equals(pc.sctp, null, 'RTCSctpTransport must be null');
+
+  let offer = await generateDataChannelOffer(pc);
+  assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
+    'SDP should have max-message-size attribute');
+
+  // Remove the max-message-size SDP attribute
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithoutAttribute(offer.sdp) };
+  await pc.setRemoteDescription(offer);
+  const answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  // Test outcome depends on canSendSize value
+  if (canSendSize !== 0) {
+    assert_equals(pc.sctp.maxMessageSize, Math.min(65536, canSendSize),
+      'Missing SDP attribute and a non-zero canSendSize should give an maxMessageSize of min(65536, canSendSize)');
+  } else {
+    assert_equals(pc.sctp.maxMessageSize, 65536,
+      'Missing SDP attribute and a canSendSize of 0 should give an maxMessageSize of 65536');
+  }
 }, 'Remote offer SDP missing max-message-size attribute');
 
-promise_test(t => {
+promise_test(async (t) => {
+  assert_not_equals(canSendSize, null, 'canSendSize needs to be determined');
+
   const pc = new RTCPeerConnection();
   t.add_cleanup(() => pc.close());
-  assert_equals(pc.sctp, null);
-
-  return generateDataChannelOffer(pc)
-  .then((offer) => {
-    assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
-      'SDP should have max-message-size attribute');
-
-    offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, remoteValue1) };
-    return pc.setRemoteDescription(offer);
-  })
-  .then(() => pc.createAnswer())
-  .then((answer) => pc.setLocalDescription(answer))
-  .then(() => {
-    assert_not_equals(pc.sctp, null);
-    assert_equals(pc.sctp.maxMessageSize, remoteValue1,
-      'maxMessageSize should be the value provided by the remote peer (as long as it is less than canSendSize)');
-  });
+
+  assert_equals(pc.sctp, null, 'RTCSctpTransport must be null');
+
+  let offer = await generateDataChannelOffer(pc);
+  assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
+    'SDP should have max-message-size attribute');
+
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, remoteSize1) };
+  await pc.setRemoteDescription(offer);
+  const answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  assert_equals(pc.sctp.maxMessageSize, remoteSize1,
+    'maxMessageSize should be the value provided by the remote peer (as long as it is less than canSendSize)');
 }, 'max-message-size with a (non-zero) value provided by the remote peer');
 
-promise_test(t => {
+promise_test(async (t) => {
+  assert_not_equals(canSendSize, null, 'canSendSize needs to be determined');
+
   const pc = new RTCPeerConnection();
   t.add_cleanup(() => pc.close());
-  assert_equals(pc.sctp, null);
-
-  return generateDataChannelOffer(pc)
-  .then((offer) => {
-    assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
-      'SDP should have max-message-size attribute');
-
-    offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, remoteValue1) };
-    return pc.setRemoteDescription(offer)
-  })
-  .then(() => pc.createAnswer())
-  .then((answer) => pc.setLocalDescription(answer))
-  .then(() => {
-    assert_not_equals(pc.sctp, null);
-    assert_equals(pc.sctp.maxMessageSize, remoteValue1,
-      'maxMessageSize should be the value provided by the remote peer (as long as it is less than canSendSize)');
-  })
-  .then(() => pc.createOffer()) // Start new O/A exchange that updates max-message-size
-  .then((offer) => {
-    offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, remoteValue2)};
-    return pc.setRemoteDescription(offer)
-  })
-  .then(() => pc.createAnswer())
-  .then((answer) => pc.setLocalDescription(answer))
-  .then(() => {
-    assert_not_equals(pc.sctp, null);
-    assert_equals(pc.sctp.maxMessageSize, remoteValue2,
-      'maxMessageSize should be the new value provided by the remote peer (as long as it is less than canSendSize)');
-  })
-  ;
-}, 'Renegotiate max-message-size with a (non-zero) value provided by the remote peer');
-
-promise_test(t => {
+
+  assert_equals(pc.sctp, null, 'RTCSctpTransport must be null');
+
+  let offer = await generateDataChannelOffer(pc);
+  assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
+    'SDP should have max-message-size attribute');
+
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, remoteSize1) };
+  await pc.setRemoteDescription(offer);
+  let answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  assert_equals(pc.sctp.maxMessageSize, remoteSize1,
+    'maxMessageSize should be the value provided by the remote peer (as long as it is less than canSendSize)');
+
+  // Start new O/A exchange that updates max-message-size to remoteSize2
+  offer = await pc.createOffer();
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, remoteSize2)};
+  await pc.setRemoteDescription(offer);
+  answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  assert_equals(pc.sctp.maxMessageSize, remoteSize2,
+    'maxMessageSize should be the new value provided by the remote peer (as long as it is less than canSendSize)');
+
+  // Start new O/A exchange that updates max-message-size to zero
+  offer = await pc.createOffer();
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, 0)};
+  await pc.setRemoteDescription(offer);
+  answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  assert_equals(pc.sctp.maxMessageSize, canSendSize,
+    'maxMessageSize should be canSendSize');
+
+  // Start new O/A exchange that updates max-message-size to remoteSize1 again
+  offer = await pc.createOffer();
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, remoteSize1)};
+  await pc.setRemoteDescription(offer);
+  answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  assert_equals(pc.sctp.maxMessageSize, remoteSize1,
+    'maxMessageSize should be the new value provided by the remote peer (as long as it is less than canSendSize)');
+}, 'Renegotiate max-message-size with various values provided by the remote peer');
+
+promise_test(async (t) => {
+  assert_not_equals(canSendSize, null, 'canSendSize needs to be determined');
+
   const pc = new RTCPeerConnection();
   t.add_cleanup(() => pc.close());
-  assert_equals(pc.sctp, null);
-  const largerThanCanSendSize = canSendSize + 1;
-
-  return generateDataChannelOffer(pc)
-  .then((offer) => {
-    assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
-      'SDP should have max-message-size attribute');
-
-    offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, largerThanCanSendSize) };
-    return pc.setRemoteDescription(offer)
-  })
-  .then(() => pc.createAnswer())
-  .then((answer) => pc.setLocalDescription(answer))
-  .then(() => {
-    assert_not_equals(pc.sctp, null);
-    // Test outcome depends on canSendSize value
-    if (canSendSize) {
-      assert_equals(pc.sctp.maxMessageSize, canSendSize,
-        'A remote value larger than a non-zero canSendSize should limit maxMessageSize to canSendSize');
-    } else {
-      assert_equals(pc.sctp.maxMessageSize, 65536,
-        'A canSendSize of zero should let the remote value set maxMessageSize');
-    }
-  });
+
+  assert_equals(pc.sctp, null, 'RTCSctpTransport must be null');
+  const largerThanCanSendSize = canSendSize === 0 ? 0 : canSendSize + 1;
+
+  let offer = await generateDataChannelOffer(pc);
+  assert_not_equals(mmsAttributeHelper.getValue(offer.sdp), null,
+    'SDP should have max-message-size attribute');
+
+  offer = { type: 'offer', sdp: mmsAttributeHelper.sdpWithValue(offer.sdp, largerThanCanSendSize) };
+  await pc.setRemoteDescription(offer);
+  const answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+
+  assert_not_equals(pc.sctp, null, 'RTCSctpTransport must be available');
+  // Test outcome depends on canSendSize value
+  if (canSendSize !== 0) {
+    assert_equals(pc.sctp.maxMessageSize, canSendSize,
+      'A remote value larger than a non-zero canSendSize should limit maxMessageSize to canSendSize');
+  } else {
+    assert_equals(pc.sctp.maxMessageSize, Number.POSITIVE_INFINITY,
+      'A remote value of zero and canSendSize zero should result in "infinity"');
+  }
 }, 'max-message-size with a (non-zero) value larger than canSendSize provided by the remote peer');
 
 </script>
diff --git a/webrtc/historical.html b/webrtc/historical.html
index ffa28be5bca307..ae7a29dec0c184 100644
--- a/webrtc/historical.html
+++ b/webrtc/historical.html
@@ -4,9 +4,14 @@
 <script src="/resources/testharnessreport.js"></script>
 <div id="log"></div>
 <script>
-test(function() {
-  assert_false("reliable" in RTCDataChannel.prototype);
-}, "RTCDataChannel member reliable should not exist");
+[
+  'reliable',
+  'maxRetransmitTime',
+].forEach((member) => {
+  test(() => {
+    assert_false(member in RTCDataChannel.prototype);
+  }, `RTCDataChannel member ${member} should not exist`);
+});
 
 [
   "addStream",