<!doctype html>
<meta charset=utf-8>
<meta name="timeout" content="long">
<title>RTCPeerConnection.prototype.setRemoteDescription - add/remove remote tracks</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="RTCPeerConnection-helper.js"></script>
<script>
  'use strict';

  // The following helper functions are called from RTCPeerConnection-helper.js:
  //   addEventListenerPromise
  //   exchangeOffer
  //   exchangeOfferAnswer
  //   Resolver

  // These tests are concerned with the observable consequences of processing
  // the addition or removal of remote tracks, including events firing and the
  // states of RTCPeerConnection, MediaStream and MediaStreamTrack.

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    caller.addTrack(localStream.getTracks()[0]);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      assert_equals(e.streams.length, 0, 'No remote stream created.');
    });
    await exchangeOffer(caller, callee);
    await ontrackPromise;
  }, 'addTrack() with a track and no stream makes ontrack fire with a track and no stream.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    caller.addTrack(localStream.getTracks()[0], localStream);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      assert_equals(e.streams.length, 1, 'Created a single remote stream.');
      assert_equals(e.streams[0].id, localStream.id,
                    'Local and remote stream IDs match.');
      assert_array_equals(e.streams[0].getTracks(), [e.track],
                          'The remote stream contains the remote track.');
    });
    await exchangeOffer(caller, callee);
    await ontrackPromise;
  }, 'addTrack() with a track and a stream makes ontrack fire with a track and a stream.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    let eventSequence = '';
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    caller.addTrack(localStream.getTracks()[0], localStream);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      eventSequence += 'ontrack;';
    });
    await exchangeOffer(caller, callee);
    eventSequence += 'setRemoteDescription;';
    await ontrackPromise;
    assert_equals(eventSequence, 'ontrack;setRemoteDescription;');
  }, 'ontrack fires before setRemoteDescription resolves.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStreams = await Promise.all([
      getNoiseStream({audio: true}),
      getNoiseStream({audio: true}),
    ]);
    t.add_cleanup(() => localStreams.forEach((stream) =>
      stream.getTracks().forEach((track) => track.stop())));
    caller.addTrack(localStreams[0].getTracks()[0], localStreams[0]);
    caller.addTrack(localStreams[1].getTracks()[0], localStreams[0]);
    let ontrackEventsFired = 0;
    const ontrackEventResolvers = [ new Resolver(), new Resolver() ];
    callee.ontrack = t.step_func(e => {
      ontrackEventResolvers[ontrackEventsFired++].resolve(e);
    });
    await exchangeOffer(caller, callee);
    let firstTrackEvent = await ontrackEventResolvers[0];
    assert_equals(firstTrackEvent.streams.length, 1,
                  'First ontrack fires with a single stream.');
    assert_equals(firstTrackEvent.streams[0].id,
                  localStreams[0].id,
                  'First ontrack\'s stream ID matches local stream.');
    let secondTrackEvent = await ontrackEventResolvers[1];
    assert_equals(secondTrackEvent.streams.length, 1,
                  'Second ontrack fires with a single stream.');
    assert_equals(secondTrackEvent.streams[0].id,
                  localStreams[0].id,
                  'Second ontrack\'s stream ID matches local stream.');
    assert_array_equals(firstTrackEvent.streams, secondTrackEvent.streams,
                        'ontrack was fired with the same streams both times.');

    assert_equals(firstTrackEvent.streams[0].getTracks().length, 2, "stream should have two tracks");
    assert_true(firstTrackEvent.streams[0].getTracks().includes(firstTrackEvent.track), "remoteStream should have the first track");
    assert_true(firstTrackEvent.streams[0].getTracks().includes(secondTrackEvent.track), "remoteStream should have the second track");
    assert_equals(ontrackEventsFired, 2, 'Unexpected number of track events.');

    assert_equals(ontrackEventsFired, 2, 'Unexpected number of track events.');
  }, 'addTrack() with two tracks and one stream makes ontrack fire twice with the tracks and shared stream.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    let eventSequence = '';
    const localStreams = await Promise.all([
      getNoiseStream({audio: true}),
      getNoiseStream({audio: true}),
    ]);
    t.add_cleanup(() => localStreams.forEach((stream) =>
      stream.getTracks().forEach((track) => track.stop())));
    caller.addTrack(localStreams[0].getTracks()[0], localStreams[0]);
    const remoteStreams = [];
    callee.ontrack = e => {
      if (!remoteStreams.includes(e.streams[0]))
        remoteStreams.push(e.streams[0]);
    };
    exchangeIceCandidates(caller, callee);
    await exchangeOfferAnswer(caller, callee);
    assert_equals(remoteStreams.length, 1, 'One remote stream created.');
    assert_equals(remoteStreams[0].id, localStreams[0].id,
                  'First local and remote streams have the same ID.');
    const firstRemoteTrack = remoteStreams[0].getTracks()[0];
    const onaddtrackPromise = addEventListenerPromise(t, remoteStreams[0], 'addtrack');
    caller.addTrack(localStreams[1].getTracks()[0], localStreams[0]);
    await exchangeOffer(caller, callee);
    const e = await onaddtrackPromise;
    assert_equals(remoteStreams[0].getTracks().length, 2, 'stream has two tracks');
    assert_not_equals(e.track.id, firstRemoteTrack.id,
                      'addtrack event has a new track');
    assert_equals(remoteStreams.length, 1, 'Still a single remote stream.');
  }, 'addTrack() for an existing stream makes stream.onaddtrack fire.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    let eventSequence = '';
    const localStreams = await Promise.all([
      getNoiseStream({audio: true}),
      getNoiseStream({audio: true}),
    ]);
    t.add_cleanup(() => localStreams.forEach((stream) =>
      stream.getTracks().forEach((track) => track.stop())));
    caller.addTrack(localStreams[0].getTracks()[0], localStreams[0]);
    const remoteStreams = [];
    callee.ontrack = e => {
      if (!remoteStreams.includes(e.streams[0]))
        remoteStreams.push(e.streams[0]);
    };
    exchangeIceCandidates(caller, callee);
    await exchangeOfferAnswer(caller, callee);
    assert_equals(remoteStreams.length, 1, 'One remote stream created.');
    const onaddtrackPromise =
        addEventListenerPromise(t, remoteStreams[0], 'addtrack', e => {
      eventSequence += 'stream.onaddtrack;';
    });
    caller.addTrack(localStreams[1].getTracks()[0], localStreams[0]);
    await exchangeOffer(caller, callee);
    eventSequence += 'setRemoteDescription;';
    await onaddtrackPromise;
    assert_equals(remoteStreams.length, 1, 'Still a single remote stream.');
    assert_equals(eventSequence, 'stream.onaddtrack;setRemoteDescription;');
  }, 'stream.onaddtrack fires before setRemoteDescription resolves.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStreams = await Promise.all([
      getNoiseStream({audio: true}),
      getNoiseStream({audio: true}),
    ]);
    t.add_cleanup(() => localStreams.forEach((stream) =>
      stream.getTracks().forEach((track) => track.stop())));
    caller.addTrack(localStreams[0].getTracks()[0],
                    localStreams[0], localStreams[1]);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      assert_equals(e.streams.length, 2, 'Two remote stream created.');
      assert_array_equals(e.streams[0].getTracks(), [e.track],
                          'First remote stream == [remote track].');
      assert_array_equals(e.streams[1].getTracks(), [e.track],
                          'Second remote stream == [remote track].');
      assert_equals(e.streams[0].id, localStreams[0].id,
                    'First local and remote stream IDs match.');
      assert_equals(e.streams[1].id, localStreams[1].id,
                    'Second local and remote stream IDs match.');
    });
    await exchangeOffer(caller, callee);
    await ontrackPromise;
  }, 'addTrack() with a track and two streams makes ontrack fire with a track and two streams.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    caller.addTrack(localStream.getTracks()[0], localStream);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      assert_array_equals(callee.getReceivers(), [e.receiver],
                          'getReceivers() == [e.receiver].');
    });
    await exchangeOffer(caller, callee);
    await ontrackPromise;
  }, 'ontrack\'s receiver matches getReceivers().');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    const sender = caller.addTrack(localStream.getTracks()[0], localStream);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track');
    exchangeIceCandidates(caller, callee);
    await exchangeOfferAnswer(caller, callee);
    await ontrackPromise;
    assert_equals(callee.getReceivers().length, 1, 'One receiver created.');
    caller.removeTrack(sender);
    await exchangeOffer(caller, callee);
    assert_equals(callee.getReceivers().length, 1, 'Receiver not removed.');
  }, 'removeTrack() does not remove the receiver.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    const [track] = localStream.getTracks();
    const sender = caller.addTrack(track, localStream);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      assert_equals(e.streams.length, 1);
      return e.streams[0];
    });
    exchangeIceCandidates(caller, callee);
    await exchangeOfferAnswer(caller, callee);
    const remoteStream = await ontrackPromise;
    const remoteTrack = remoteStream.getTracks()[0];
    const onremovetrackPromise =
        addEventListenerPromise(t, remoteStream, 'removetrack', e => {
      assert_equals(e.track, remoteTrack);
      assert_equals(remoteStream.getTracks().length, 0,
                    'Remote stream emptied of tracks.');
    });
    caller.removeTrack(sender);
    await exchangeOffer(caller, callee);
    await onremovetrackPromise;
  }, 'removeTrack() makes stream.onremovetrack fire and the track to be removed from the stream.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    let eventSequence = '';
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    const sender = caller.addTrack(localStream.getTracks()[0], localStream);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      assert_equals(e.streams.length, 1);
      return e.streams[0];
    });
    exchangeIceCandidates(caller, callee);
    await exchangeOfferAnswer(caller, callee);
    const remoteStream = await ontrackPromise;
    const remoteTrack = remoteStream.getTracks()[0];
    const onremovetrackPromise =
        addEventListenerPromise(t, remoteStream, 'removetrack', e => {
      eventSequence += 'stream.onremovetrack;';
    });
    caller.removeTrack(sender);
    await exchangeOffer(caller, callee);
    eventSequence += 'setRemoteDescription;';
    await onremovetrackPromise;
    assert_equals(eventSequence, 'stream.onremovetrack;setRemoteDescription;');
  }, 'stream.onremovetrack fires before setRemoteDescription resolves.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    const sender = caller.addTrack(localStream.getTracks()[0], localStream);
    exchangeIceCandidates(caller, callee);
    const e = await exchangeOfferAndListenToOntrack(t, caller, callee);
    const remoteTrack = e.track;

    // Need to wait for unmute, otherwise there's no event for the transition
    // back to muted.
    const onunmutePromise =
        addEventListenerPromise(t, remoteTrack, 'unmute', () => {
      assert_false(remoteTrack.muted);
    });
    await exchangeAnswer(caller, callee);
    await onunmutePromise;

    const onmutePromise =
        addEventListenerPromise(t, remoteTrack, 'mute', () => {
      assert_true(remoteTrack.muted);
    });
    caller.removeTrack(sender);
    await exchangeOffer(caller, callee);
    await onmutePromise;
  }, 'removeTrack() makes track.onmute fire and the track to be muted.');

  promise_test(async t => {
    const caller = new RTCPeerConnection();
    t.add_cleanup(() => caller.close());
    const callee = new RTCPeerConnection();
    t.add_cleanup(() => callee.close());
    let eventSequence = '';
    const localStream =
        await getNoiseStream({audio: true});
    t.add_cleanup(() => localStream.getTracks().forEach(track => track.stop()));
    const sender = caller.addTrack(localStream.getTracks()[0], localStream);
    const ontrackPromise = addEventListenerPromise(t, callee, 'track', e => {
      assert_equals(e.streams.length, 1);
      return e.streams[0];
    });
    exchangeIceCandidates(caller, callee);
    const e = await exchangeOfferAndListenToOntrack(t, caller, callee);
    const remoteTrack = e.track;

    // Need to wait for unmute, otherwise there's no event for the transition
    // back to muted.
    const onunmutePromise =
        addEventListenerPromise(t, remoteTrack, 'unmute', () => {
      assert_false(remoteTrack.muted);
    });
    await exchangeAnswer(caller, callee);
    await onunmutePromise;

    const onmutePromise =
        addEventListenerPromise(t, remoteTrack, 'mute', () => {
      eventSequence += 'track.onmute;';
    });
    caller.removeTrack(sender);
    await exchangeOffer(caller, callee);
    eventSequence += 'setRemoteDescription;';
    await onmutePromise;
    assert_equals(eventSequence, 'track.onmute;setRemoteDescription;');
  }, 'track.onmute fires before setRemoteDescription resolves.');

  promise_test(async t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const stream = await getNoiseStream({audio: true});
    t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
    const sender = pc.addTrack(stream.getTracks()[0]);
    pc.removeTrack(sender);
    pc.removeTrack(sender);
  }, 'removeTrack() twice is safe.');
</script>