<!doctype html>
<meta charset="utf-8">
<title>Test RTCPeerConnection.prototype.onnegotiationneeded</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://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html

  // The following helper functions are called from RTCPeerConnection-helper.js:
  //   generateAnswer
  //   generateAudioReceiveOnlyOffer
  //   test_never_resolve

  // Listen to the negotiationneeded event on a peer connection
  // Returns a promise that resolves when the first event is fired.
  // The resolve result is a dictionary with event and nextPromise,
  // which resolves when the next negotiationneeded event is fired.
  // This allow us to promisify the event listening and assert whether
  // an event is fired or not by testing whether a promise is resolved.
  function awaitNegotiation(pc) {
    if(pc.onnegotiationneeded) {
      throw new Error('connection is already attached with onnegotiationneeded event handler');
    }

    function waitNextNegotiation() {
      return new Promise(resolve => {
        pc.onnegotiationneeded = event => {
          const nextPromise = waitNextNegotiation();
          resolve({ nextPromise, event });
        }
      });
    }

    return waitNextNegotiation();
  }

  // Return a promise that rejects if the first promise is resolved before second promise.
  // Also rejects when either promise rejects.
  function assert_first_promise_fulfill_after_second(promise1, promise2, message) {
    if(!message) {
      message = 'first promise is resolved before second promise';
    }

    return new Promise((resolve, reject) => {
      let secondResolved = false;

      promise1.then(() => {
        if(secondResolved) {
          resolve();
        } else {
          assert_unreached(message);
        }
      })
      .catch(reject);

      promise2.then(() => {
        secondResolved = true;
      }, reject);
    });
  }

  /*
    4.7.3.  Updating the Negotiation-Needed flag

      To update the negotiation-needed flag
      5.  Set connection's [[needNegotiation]] slot to true.
      6.  Queue a task that runs the following steps:
          3.  Fire a simple event named negotiationneeded at connection.

      To check if negotiation is needed
      2.  If connection has created any RTCDataChannels, and no m= section has
          been negotiated yet for data, return "true".

    6.1.  RTCPeerConnection Interface Extensions

      createDataChannel
        14. If channel was the first RTCDataChannel created on connection,
            update the negotiation-needed flag for connection.
   */
  promise_test(t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const negotiated = awaitNegotiation(pc);

    pc.createDataChannel('test');
    return negotiated;
  }, 'Creating first data channel should fire negotiationneeded event');

  test_never_resolve(t => {
    const pc = new RTCPeerConnection();
    const negotiated = awaitNegotiation(pc);

    pc.createDataChannel('foo');
    return negotiated
      .then(({nextPromise}) => {
      pc.createDataChannel('bar');
      return nextPromise;
    });
  }, 'calling createDataChannel twice should fire negotiationneeded event once');

  /*
    4.7.3.  Updating the Negotiation-Needed flag
      To check if negotiation is needed
      3.  For each transceiver t in connection's set of transceivers, perform
          the following checks:
          1.  If t isn't stopped and isn't yet associated with an m= section
              according to [JSEP] (section 3.4.1.), return "true".

    5.1.  RTCPeerConnection Interface Extensions
      addTransceiver
        9.  Update the negotiation-needed flag for connection.
   */
  promise_test(t => {
    const pc = new RTCPeerConnection();
    t.add_cleanup(() => pc.close());
    const negotiated = awaitNegotiation(pc);

    pc.addTransceiver('audio');
    return negotiated;
  }, 'addTransceiver() should fire negotiationneeded event');

  /*
    4.7.3.  Updating the Negotiation-Needed flag
      To update the negotiation-needed flag
      4.  If connection's [[needNegotiation]] slot is already true, abort these steps.
   */
  test_never_resolve(t => {
    const pc = new RTCPeerConnection();
    const negotiated = awaitNegotiation(pc);

    pc.addTransceiver('audio');
    return negotiated
    .then(({nextPromise}) => {
      pc.addTransceiver('video');
      return nextPromise;
    });
  }, 'Calling addTransceiver() twice should fire negotiationneeded event once');

  /*
    4.7.3.  Updating the Negotiation-Needed flag
      To update the negotiation-needed flag
      4.  If connection's [[needNegotiation]] slot is already true, abort these steps.
   */
  test_never_resolve(t => {
    const pc = new RTCPeerConnection();
    const negotiated = awaitNegotiation(pc);

    pc.createDataChannel('test');
    return negotiated
    .then(({nextPromise}) => {
      pc.addTransceiver('video');
      return nextPromise;
    });
  }, 'Calling both addTransceiver() and createDataChannel() should fire negotiationneeded event once');

  /*
    4.7.3.  Updating the Negotiation-Needed flag
      To update the negotiation-needed flag
      2.  If connection's signaling state is not "stable", abort these steps.
   */
  test_never_resolve(t => {
    const pc = new RTCPeerConnection();
    let negotiated;

    return generateAudioReceiveOnlyOffer(pc)
    .then(offer => {
      pc.setLocalDescription(offer);
      negotiated = awaitNegotiation(pc);
    })
    .then(() => negotiated)
    .then(({nextPromise}) => {
      assert_equals(pc.signalingState, 'have-local-offer');
      pc.createDataChannel('test');
      return nextPromise;
    });
  }, 'negotiationneeded event should not fire if signaling state is not stable');

  /*
    4.4.1.6.  Set the RTCSessionSessionDescription
      2.2.10. If connection's signaling state is now stable, update the negotiation-needed
              flag. If connection's [[NegotiationNeeded]] slot was true both before and after
              this update, queue a task that runs the following steps:
        2.  If connection's [[NegotiationNeeded]] slot is false, abort these steps.
        3.  Fire a simple event named negotiationneeded at connection.
   */
  promise_test(async t => {
    const pc = new RTCPeerConnection();

    t.add_cleanup(() => pc.close());

    pc.addTransceiver('audio');
    const offer = await pc.createOffer();
    await pc.setLocalDescription(offer);
    let fired = false;
    pc.onnegotiationneeded = e => fired = true;
    pc.createDataChannel('test');
    const answer = await generateAnswer(offer);
    await pc.setRemoteDescription(answer);
    assert_false(fired, "negotiationneeded should not fire until the next iteration of the event loop after returning to stable");
    await new Promise(resolve => pc.onnegotiationneeded = resolve);
  }, 'negotiationneeded event should fire only after signaling state go back to stable');

  /*
    TODO
    4.7.3.  Updating the Negotiation-Needed flag

      To update the negotiation-needed flag
      3.  If the result of checking if negotiation is needed is "false",
          clear the negotiation-needed flag by setting connection's
          [[needNegotiation]] slot to false, and abort these steps.
      6.  Queue a task that runs the following steps:
          2.  If connection's [[needNegotiation]] slot is false, abort these steps.

      To check if negotiation is needed
      3.  For each transceiver t in connection's set of transceivers, perform
          the following checks:
          2.  If t isn't stopped and is associated with an m= section according
              to [JSEP] (section 3.4.1.), then perform the following checks:
              1.  If t's direction is "sendrecv" or "sendonly", and the
                  associated m= section in connection's currentLocalDescription
                  doesn't contain an "a=msid" line, return "true".
              2.  If connection's currentLocalDescription if of type "offer",
                  and the direction of the associated m= section in neither the
                  offer nor answer matches t's direction, return "true".
              3.  If connection's currentLocalDescription if of type "answer",
                  and the direction of the associated m= section in the answer
                  does not match t's direction intersected with the offered
                  direction (as described in [JSEP] (section 5.3.1.)),
                  return "true".
          3.  If t is stopped and is associated with an m= section according
              to [JSEP] (section 3.4.1.), but the associated m= section is
              not yet rejected in connection's currentLocalDescription or
              currentRemoteDescription , return "true".
      4.  If all the preceding checks were performed and "true" was not returned,
          nothing remains to be negotiated; return "false".

    4.3.1.  RTCPeerConnection Operation

      When the RTCPeerConnection() constructor is invoked
        7.  Let connection have a [[needNegotiation]] internal slot, initialized to false.

    5.1.  RTCPeerConnection Interface Extensions

      addTrack
        10. Update the negotiation-needed flag for connection.

      removeTrack
        12. Update the negotiation-needed flag for connection.

    5.4.  RTCRtpTransceiver Interface

      setDirection
        7.  Update the negotiation-needed flag for connection.

      stop
        11. Update the negotiation-needed flag for connection.

    Untestable
    4.7.3.  Updating the Negotiation-Needed flag
      1.  If connection's [[isClosed]] slot is true, abort these steps.
      6.  Queue a task that runs the following steps:
          1.  If connection's [[isClosed]] slot is true, abort these steps.
   */

</script>