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
|
<!doctype html>
<meta charset=utf-8>
<title>RTCPeerConnection.prototype.setRemoteDescription</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:
// assert_session_desc_not_similar()
// assert_session_desc_similar()
/*
4.3.2. Interface Definition
[Constructor(optional RTCConfiguration configuration)]
interface RTCPeerConnection : EventTarget {
Promise<void> setRemoteDescription(
RTCSessionDescriptionInit description);
readonly attribute RTCSessionDescription? remoteDescription;
readonly attribute RTCSessionDescription? currentRemoteDescription;
readonly attribute RTCSessionDescription? pendingRemoteDescription;
...
};
4.6.2. RTCSessionDescription Class
dictionary RTCSessionDescriptionInit {
required RTCSdpType type;
DOMString sdp = "";
};
4.6.1. RTCSdpType
enum RTCSdpType {
"offer",
"pranswer",
"answer",
"rollback"
};
*/
/*
4.6.1. enum RTCSdpType
*/
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
// SDP is validated after WebIDL validation
try {
await pc.setRemoteDescription({ type: 'bogus', sdp: 'bogus' });
t.unreached_func("Should have rejected.");
} catch (e) {
assert_throws_js(TypeError, () => { throw e });
}
}, 'setRemoteDescription with invalid type and invalid SDP should reject with TypeError');
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
// SDP is validated after validating type
try {
await pc.setRemoteDescription({ type: 'answer', sdp: 'invalid' });
t.unreached_func("Should have rejected.");
} catch (e) {
assert_throws_dom('InvalidStateError', () => { throw e });
}
}, 'setRemoteDescription() with invalid SDP and stable state should reject with InvalidStateError');
/* Dedicated signalingstate events test. */
promise_test(async t => {
const pc = new RTCPeerConnection();
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
t.add_cleanup(() => pc2.close());
let eventCount = 0;
const states = [
'stable', 'have-local-offer', 'stable', 'have-remote-offer',
];
pc.onsignalingstatechange = t.step_func(() =>
assert_equals(pc.signalingState, states[++eventCount]));
const assert_state = state => {
assert_equals(state, pc.signalingState);
assert_equals(state, states[eventCount]);
};
const offer = await generateAudioReceiveOnlyOffer(pc);
assert_state('stable');
await pc.setLocalDescription(offer);
assert_state('have-local-offer');
await pc2.setRemoteDescription(offer);
await exchangeAnswer(pc, pc2);
assert_state('stable');
await exchangeOffer(pc2, pc);
assert_state('have-remote-offer');
}, 'Negotiation should fire signalingsstate events');
/* Operations after returning to stable state */
promise_test(async t => {
const pc = new RTCPeerConnection();
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
t.add_cleanup(() => pc2.close());
const offer1 = await generateAudioReceiveOnlyOffer(pc2);
await pc2.setLocalDescription(offer1);
await pc.setRemoteDescription(offer1);
await exchangeAnswer(pc2, pc);
const offer2 = await generateVideoReceiveOnlyOffer(pc2);
await pc2.setLocalDescription(offer2);
await pc.setRemoteDescription(offer2);
assert_session_desc_not_similar(offer1, offer2);
assert_session_desc_similar(pc.remoteDescription, offer2);
assert_session_desc_similar(pc.currentRemoteDescription, offer1);
assert_session_desc_similar(pc.pendingRemoteDescription, offer2);
}, 'Calling setRemoteDescription() again after one round of remote-offer/local-answer should succeed');
promise_test(async t => {
const pc = new RTCPeerConnection();
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
t.add_cleanup(() => pc2.close());
const offer = await generateAudioReceiveOnlyOffer(pc);
await pc.setLocalDescription(offer);
await pc2.setRemoteDescription(offer);
const answer = await pc2.createAnswer();
await pc2.setLocalDescription(answer);
await pc.setRemoteDescription(answer);
await exchangeOffer(pc2, pc);
assert_equals(pc.remoteDescription, pc.pendingRemoteDescription);
assert_session_desc_similar(pc.remoteDescription, offer);
assert_session_desc_similar(pc.currentRemoteDescription, answer);
}, 'Switching role from offerer to answerer after going back to stable state should succeed');
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const offer = await pc.createOffer();
const p = Promise.race([
pc.setRemoteDescription(offer),
new Promise(r => t.step_timeout(() => r("timeout"), 200))
]);
pc.close();
assert_equals(await p, "timeout");
assert_equals(pc.signalingState, "closed", "In closed state");
}, 'Closing on setRemoteDescription() neither resolves nor rejects');
promise_test(async t => {
const pc = new RTCPeerConnection();
t.add_cleanup(() => pc.close());
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
const p = Promise.race([
pc.setRemoteDescription(offer),
new Promise(r => t.step_timeout(() => r("timeout"), 200))
]);
pc.close();
assert_equals(await p, "timeout");
assert_equals(pc.signalingState, "closed", "In closed state");
}, 'Closing on rollback neither resolves nor rejects');
</script>
|
