From 086c044dc34dfc0f74fbe41f4ecb402b2cd34884 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Fri, 19 Apr 2024 03:13:33 +0200
Subject: Merging upstream version 125.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../tests/webrtc/RTCPeerConnection-helper.js       | 142 ++++++++++++++++++++-
 1 file changed, 141 insertions(+), 1 deletion(-)

(limited to 'testing/web-platform/tests/webrtc/RTCPeerConnection-helper.js')

diff --git a/testing/web-platform/tests/webrtc/RTCPeerConnection-helper.js b/testing/web-platform/tests/webrtc/RTCPeerConnection-helper.js
index 5d188328e8..6f35fde76c 100644
--- a/testing/web-platform/tests/webrtc/RTCPeerConnection-helper.js
+++ b/testing/web-platform/tests/webrtc/RTCPeerConnection-helper.js
@@ -236,6 +236,11 @@ async function waitForIceGatheringState(pc, wantedStates) {
   }
 }
 
+async function waitForTrackUnmuted(track) {
+  if (track.muted === false) return true;
+  return waitUntilEvent(track, 'unmute');
+}
+
 // Resolves when RTP packets have been received.
 async function listenForSSRCs(t, receiver) {
   while (true) {
@@ -646,7 +651,7 @@ function findTransceiverForSender(pc, sender) {
 }
 
 function preferCodec(transceiver, mimeType, sdpFmtpLine) {
-  const {codecs} = RTCRtpSender.getCapabilities(transceiver.receiver.track.kind);
+  const {codecs} = RTCRtpReceiver.getCapabilities(transceiver.receiver.track.kind);
   // sdpFmtpLine is optional, pick the first partial match if not given.
   const selectedCodecIndex = codecs.findIndex(c => {
     return c.mimeType === mimeType && (c.sdpFmtpLine === sdpFmtpLine || !sdpFmtpLine);
@@ -696,6 +701,7 @@ const iceGatheringStateTransitions = async (pc, ...states) => {
       }, {once: true});
     });
   }
+  return states;
 };
 
 const initialOfferAnswerWithIceGatheringStateTransitions =
@@ -713,6 +719,14 @@ const initialOfferAnswerWithIceGatheringStateTransitions =
       await pc2Transitions;
     };
 
+const expectNoMoreIceConnectionStateChanges = async (t, pc) => {
+  pc.oniceconnectionstatechange =
+      t.step_func(() => {
+        assert_unreached(
+            'Should not get an iceconnectionstatechange right now!');
+      });
+};
+
 const expectNoMoreGatheringStateChanges = async (t, pc) => {
   pc.onicegatheringstatechange =
       t.step_func(() => {
@@ -721,6 +735,132 @@ const expectNoMoreGatheringStateChanges = async (t, pc) => {
       });
 };
 
+function gatheringStateReached(object, state) {
+  if (object instanceof RTCIceTransport) {
+    return new Promise(r =>
+      object.addEventListener("gatheringstatechange", function listener() {
+        if (object.gatheringState == state) {
+          object.removeEventListener("gatheringstatechange", listener);
+          r(state);
+        }
+      })
+    );
+  } else if (object instanceof RTCPeerConnection) {
+    return new Promise(r =>
+      object.addEventListener("icegatheringstatechange", function listener() {
+        if (object.iceGatheringState == state) {
+          object.removeEventListener("icegatheringstatechange", listener);
+          r(state);
+        }
+      })
+    );
+  } else {
+    throw "First parameter is neither an RTCIceTransport nor an RTCPeerConnection";
+  }
+}
+
+function nextGatheringState(object) {
+  if (object instanceof RTCIceTransport) {
+    return new Promise(resolve =>
+      object.addEventListener(
+        "gatheringstatechange",
+        () => resolve(object.gatheringState),
+        { once: true }
+      )
+    );
+  } else if (object instanceof RTCPeerConnection) {
+    return new Promise(resolve =>
+      object.addEventListener(
+        "icegatheringstatechange",
+        () => resolve(object.iceGatheringState),
+        { once: true }
+      )
+    );
+  } else {
+    throw "First parameter is neither an RTCIceTransport nor an RTCPeerConnection";
+  }
+}
+
+function emptyCandidate(pc) {
+  return new Promise(r =>
+    pc.addEventListener("icecandidate", function listener(e) {
+      if (e.candidate && e.candidate.candidate == "") {
+        pc.removeEventListener("icecandidate", listener);
+        r(e);
+      }
+    })
+  );
+}
+
+function nullCandidate(pc) {
+  return new Promise(r =>
+    pc.addEventListener("icecandidate", function listener(e) {
+      if (!e.candidate) {
+        pc.removeEventListener("icecandidate", listener);
+        r(e);
+      }
+    })
+  );
+}
+
+function connectionStateReached(object, state) {
+  if (object instanceof RTCIceTransport || object instanceof RTCDtlsTransport) {
+    return new Promise(resolve =>
+      object.addEventListener("statechange", function listener() {
+        if (object.state == state) {
+          object.removeEventListener("statechange", listener);
+          resolve(state);
+        }
+      })
+    );
+  } else if (object instanceof RTCPeerConnection) {
+    return new Promise(resolve =>
+      object.addEventListener("connectionstatechange", function listener() {
+        if (object.connectionState == state) {
+          object.removeEventListener("connectionstatechange", listener);
+          resolve(state);
+        }
+      })
+    );
+  } else {
+    throw "First parameter is neither an RTCIceTransport, an RTCDtlsTransport, nor an RTCPeerConnection";
+  }
+}
+
+function nextConnectionState(object) {
+  if (object instanceof RTCIceTransport || object instanceof RTCDtlsTransport) {
+    return new Promise(resolve =>
+      object.addEventListener("statechange", () => resolve(object.state), {
+        once: true,
+      })
+    );
+  } else if (object instanceof RTCPeerConnection) {
+    return new Promise(resolve =>
+      object.addEventListener(
+        "connectionstatechange",
+        () => resolve(object.connectionState),
+        { once: true }
+      )
+    );
+  } else {
+    throw "First parameter is neither an RTCIceTransport, an RTCDtlsTransport, nor an RTCPeerConnection";
+  }
+}
+
+function nextIceConnectionState(pc) {
+  if (pc instanceof RTCPeerConnection) {
+    return new Promise(resolve =>
+      pc.addEventListener(
+        "iceconnectionstatechange",
+        () => resolve(pc.iceConnectionState),
+        { once: true }
+      )
+    );
+  } else {
+    throw "First parameter is not an RTCPeerConnection";
+  }
+}
+
 async function queueAWebrtcTask() {
   const pc = new RTCPeerConnection();
   pc.addTransceiver('audio');
-- 
cgit v1.2.3