DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (f1a26f022ec7)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
<!doctype html>
<meta charset=utf-8>
<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';

// 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;
  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;
  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');

/*
  Checks that the id is ignored if "negotiated" is false.
  See section 6.1, createDataChannel step 13.
 */
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('', {
    negotiated: false,
    id: 42
  });
  dc1.onopen = t.step_func(() => {
    dc1.send(':(');
  });

  const dc2 = pc2.createDataChannel('', {
    negotiated: false,
    id: 42
  });
  // ID should be null prior to negotiation.
  assert_equals(dc1.id, null);
  assert_equals(dc2.id, null);

  exchangeIceCandidates(pc1, pc2);
  await doSignalingHandshake(pc1, pc2);
  // We should now have 2 datachannels with different IDs.
  // At least one of the datachannels should not be 42.
  // If one has the value 42, it's an accident; if both have,
  // they are the same datachannel, and it's a bug.
  assert_false(dc1.id == 42 && dc2.id == 42);
}, 'In-band negotiation with a specific ID should not work');

/*
  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, id, 'Channel id must be set before DTLS role has been determined when negotiated is true');
    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.
 */
/* TEST DISABLED - it takes so long, it times out.
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_dom('OperationError', () =>
    pc1.createDataChannel('this is too exhausting!'));
  assert_throws_dom('OperationError', () =>
    pc2.createDataChannel('this is too exhausting!'));

  maybeDone();
  await resolver;
}, 'Channel ID exhaustion handling (before and after connection establishment)');

END DISABLED TEST */

</script>