script-transform-generateKeyFrame.https.html (10324B)
1 <!doctype html> 2 <html> 3 <head> 4 <meta charset=utf-8> 5 <title>RTCRtpScriptTransformer.generateKeyFrame tests</title> 6 <meta name='timeout' content='long'> 7 <script src='/resources/testharness.js'></script> 8 <script src='/resources/testharnessreport.js'></script> 9 <script src=/resources/testdriver.js></script> 10 <script src=/resources/testdriver-vendor.js></script> 11 <script src='../mediacapture-streams/permission-helper.js'></script> 12 </head> 13 <body> 14 <video id='video1' autoplay></video> 15 <video id='video2' autoplay></video> 16 <script src ='routines.js'></script> 17 <script src ='../webrtc/simulcast/simulcast.js'></script> 18 <script src ='../webrtc/RTCPeerConnection-helper.js'></script> 19 <script src='../webrtc/third_party/sdp/sdp.js'></script> 20 <script> 21 22 const generateKeyFrame = (port, opts) => postMethod(port, 'generateKeyFrame', opts); 23 const generateKeyFrameDoesNotThrow = (port, opts) => postMethod(port, 'generateKeyFrameDoesNotThrow', opts); 24 const waitForFrame = port => postMethod(port, 'waitForFrame'); 25 26 promise_test(async (test) => { 27 const {sender, receiver} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {audio: true}); 28 let message = await waitForFrame(sender.transform.port); 29 assert_equals(message, 'got frame'); 30 31 // No rids 32 message = await generateKeyFrame(sender.transform.port); 33 assert_equals(message.result, 'failure'); 34 assert_equals(message.value, 'InvalidStateError', `Message: ${message.message}`); 35 36 message = await waitForFrame(receiver.transform.port); 37 assert_equals(message, 'got frame'); 38 39 // No rids 40 message = await generateKeyFrame(receiver.transform.port); 41 assert_equals(message.result, 'failure'); 42 assert_equals(message.value, 'InvalidStateError', `Message: ${message.message}`); 43 }, 'generateKeyFrame() throws for audio'); 44 45 promise_test(async (test) => { 46 const {sender, receiver} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 47 let message = await waitForFrame(sender.transform.port); 48 assert_equals(message, 'got frame'); 49 50 // No rids 51 message = await generateKeyFrame(sender.transform.port); 52 assert_equals(message.result, 'success'); 53 // value should be a timestamp 54 assert_equals(typeof message.value, 'number'); 55 assert_greater_than(message.value, 0); 56 57 // No rids 58 message = await generateKeyFrame(receiver.transform.port); 59 assert_equals(message.result, 'failure'); 60 assert_equals(message.value, 'InvalidStateError', `Message: ${message.message}`); 61 62 video1.srcObject = new MediaStream([receiver.track]); 63 await video1.play(); 64 }, 'generateKeyFrame(null) resolves for video sender, and throws for video receiver'); 65 66 promise_test(async (test) => { 67 const {sender, receiver} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 68 let message = await waitForFrame(sender.transform.port); 69 assert_equals(message, 'got frame'); 70 71 // Invalid rid, empty string 72 message = await generateKeyFrame(sender.transform.port, {rid: ''}); 73 assert_equals(message.result, 'failure'); 74 assert_equals(message.value, 'NotAllowedError', `Message: ${message.message}`); 75 76 // Invalid rid, bad ASCII characters 77 message = await generateKeyFrame(sender.transform.port, {rid: '!?'}); 78 assert_equals(message.result, 'failure'); 79 assert_equals(message.value, 'NotAllowedError', `Message: ${message.message}`); 80 81 // Invalid rid, bad ASCII characters (according to RFC 8852, but not RFC 8851) 82 message = await generateKeyFrame(sender.transform.port, {rid: 'foo-bar'}); 83 assert_equals(message.result, 'failure'); 84 assert_equals(message.value, 'NotAllowedError', `Message: ${message.message}`); 85 86 // Invalid rid, bad ASCII characters (according to RFC 8852, but not RFC 8851) 87 message = await generateKeyFrame(sender.transform.port, {rid: 'foo_bar'}); 88 assert_equals(message.result, 'failure'); 89 assert_equals(message.value, 'NotAllowedError', `Message: ${message.message}`); 90 91 // Invalid rid, bad non-ASCII characters 92 message = await generateKeyFrame(sender.transform.port, {rid: '(╯°□°)╯︵ ┻━┻'}); 93 assert_equals(message.result, 'failure'); 94 assert_equals(message.value, 'NotAllowedError', `Message: ${message.message}`); 95 96 // Invalid rid, too long 97 message = await generateKeyFrame(sender.transform.port, {rid: 'a'.repeat(256)}); 98 assert_equals(message.result, 'failure'); 99 assert_equals(message.value, 'NotAllowedError', `Message: ${message.message}`); 100 }, 'generateKeyFrame throws NotAllowedError for invalid rid'); 101 102 promise_test(async (test) => { 103 const {sender, receiver} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 104 let message = await waitForFrame(sender.transform.port); 105 assert_equals(message, 'got frame'); 106 107 message = await generateKeyFrame(sender.transform.port, {rid: 'foo'}); 108 assert_equals(message.result, 'failure'); 109 assert_equals(message.value, 'NotFoundError', `Message: ${message.message}`); 110 }, 'generateKeyFrame throws NotFoundError for unknown rid'); 111 112 promise_test(async (test) => { 113 const {sender, receiver} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 114 let message = await waitForFrame(sender.transform.port); 115 assert_equals(message, 'got frame'); 116 117 message = await generateKeyFrame(sender.transform.port); 118 assert_equals(message.result, 'success'); 119 120 const senderTransform = sender.transform; 121 sender.transform = null; 122 123 message = await generateKeyFrameDoesNotThrow(senderTransform.port); 124 assert_equals(message.result, 'success'); 125 }, 'generateKeyFrame does not throw for unset transforms'); 126 127 promise_test(async (test) => { 128 const {sender, receiver} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 129 let message = await waitForFrame(sender.transform.port); 130 assert_equals(message, 'got frame'); 131 132 message = await generateKeyFrame(sender.transform.port); 133 assert_equals(message.result, 'success'); 134 // value should be a timestamp 135 assert_equals(typeof message.value, 'number'); 136 assert_greater_than(message.value, 0); 137 const timestamp = message.value; 138 139 message = await generateKeyFrame(sender.transform.port); 140 assert_equals(message.result, 'success'); 141 // value should be a timestamp 142 assert_equals(typeof message.value, 'number'); 143 assert_greater_than(message.value, timestamp); 144 }, 'generateKeyFrame timestamp should advance'); 145 146 promise_test(async (test) => { 147 const {sender, receiver} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 148 let message = await waitForFrame(sender.transform.port); 149 assert_equals(message, 'got frame'); 150 151 message = await generateKeyFrame(sender.transform.port); 152 assert_equals(message.result, 'success'); 153 const count = message.count; 154 155 message = await generateKeyFrame(sender.transform.port); 156 assert_equals(message.result, 'success'); 157 assert_greater_than(message.count, count); 158 }, 'await generateKeyFrame, await generateKeyFrame should see an increase in count of keyframes'); 159 160 promise_test(async (test) => { 161 const {sender, receiver, senderPc, receiverPc} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 162 let message = await waitForFrame(sender.transform.port); 163 assert_equals(message, 'got frame'); 164 165 message = await generateKeyFrame(sender.transform.port); 166 assert_equals(message.result, 'success'); 167 168 senderPc.getTransceivers()[0].direction = 'inactive'; 169 await senderPc.setLocalDescription(); 170 await receiverPc.setRemoteDescription(senderPc.localDescription); 171 await receiverPc.setLocalDescription(); 172 await senderPc.setRemoteDescription(receiverPc.localDescription); 173 174 message = await generateKeyFrameDoesNotThrow(sender.transform.port); 175 assert_equals(message.result, 'success'); 176 177 senderPc.getTransceivers()[0].direction = 'sendonly'; 178 await senderPc.setLocalDescription(); 179 await receiverPc.setRemoteDescription(senderPc.localDescription); 180 await receiverPc.setLocalDescription(); 181 await senderPc.setRemoteDescription(receiverPc.localDescription); 182 183 message = await generateKeyFrame(sender.transform.port); 184 assert_equals(message.result, 'success'); 185 }, 'generateKeyFrame does not reject when the sender is negotiated inactive, and resumes succeeding when negotiated back to active'); 186 187 promise_test(async (test) => { 188 const {sender, receiver, senderPc, receiverPc} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 189 let message = await waitForFrame(sender.transform.port); 190 assert_equals(message, 'got frame'); 191 192 message = await generateKeyFrame(sender.transform.port); 193 assert_equals(message.result, 'success'); 194 195 senderPc.getTransceivers()[0].stop(); 196 197 message = await generateKeyFrameDoesNotThrow(sender.transform.port); 198 assert_equals(message.result, 'success'); 199 }, 'generateKeyFrame does not reject when the sender is stopped, even without negotiation'); 200 201 promise_test(async (test) => { 202 const {sender, receiver, senderPc, receiverPc} = await createConnectionWithTransform(test, 'script-transform-generateKeyFrame.js', {video: true}); 203 let message = await waitForFrame(sender.transform.port); 204 assert_equals(message, 'got frame'); 205 206 message = await generateKeyFrame(sender.transform.port); 207 assert_equals(message.result, 'success'); 208 209 await senderPc.getTransceivers()[0].sender.replaceTrack(null); 210 211 message = await generateKeyFrameDoesNotThrow(sender.transform.port); 212 assert_equals(message.result, 'success'); 213 }, 'generateKeyFrame does not reject with a null track'); 214 215 // TODO: It would be nice to be able to test that pending generateKeyFrame 216 // promises are _rejected_ when the transform is unset, or the sender stops 217 // sending. However, getting the timing on this right is going to be very hard. 218 // While we could stop the processing of frames before calling 219 // generateKeyFrame, this would not necessarily help, because generateKeyFrame 220 // promises are resolved _before_ enqueueing the frame into |readable|, and 221 // right now the spec does not have a high water mark/backpressure on 222 // |readable|, so pausing would not necessarily prevent the enqueue. 223 </script> 224 </body> 225 </html>