1 // Copyright (c) 2018 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "third_party/blink/renderer/modules/peerconnection/call_setup_state_tracker.h"
6
7 #include "testing/gtest/include/gtest/gtest.h"
8 #include "third_party/blink/renderer/platform/wtf/vector.h"
9
10 namespace blink {
11
12 namespace {
13
14 template <typename StateType>
15 Vector<StateType> GetAllCallSetupStates();
16
17 template <>
GetAllCallSetupStates()18 Vector<OffererState> GetAllCallSetupStates() {
19 Vector<OffererState> states = {OffererState::kNotStarted,
20 OffererState::kCreateOfferPending,
21 OffererState::kCreateOfferRejected,
22 OffererState::kCreateOfferResolved,
23 OffererState::kSetLocalOfferPending,
24 OffererState::kSetLocalOfferRejected,
25 OffererState::kSetLocalOfferResolved,
26 OffererState::kSetRemoteAnswerPending,
27 OffererState::kSetRemoteAnswerRejected,
28 OffererState::kSetRemoteAnswerResolved};
29 EXPECT_EQ(static_cast<size_t>(OffererState::kMaxValue) + 1u, states.size());
30 return states;
31 }
32
33 template <>
GetAllCallSetupStates()34 Vector<AnswererState> GetAllCallSetupStates() {
35 Vector<AnswererState> states = {AnswererState::kNotStarted,
36 AnswererState::kSetRemoteOfferPending,
37 AnswererState::kSetRemoteOfferRejected,
38 AnswererState::kSetRemoteOfferResolved,
39 AnswererState::kCreateAnswerPending,
40 AnswererState::kCreateAnswerRejected,
41 AnswererState::kCreateAnswerResolved,
42 AnswererState::kSetLocalAnswerPending,
43 AnswererState::kSetLocalAnswerRejected,
44 AnswererState::kSetLocalAnswerResolved};
45 EXPECT_EQ(static_cast<size_t>(AnswererState::kMaxValue) + 1u, states.size());
46 return states;
47 }
48
49 } // namespace
50
51 class CallSetupStateTrackerTest : public testing::Test {
52 public:
53 enum class Reachability {
54 kReachable,
55 kUnreachable,
56 };
57
58 template <typename StateType>
59 StateType current_state() const;
60
NoteStateEvent(CallSetupStateTracker * tracker,OffererState event) const61 bool NoteStateEvent(CallSetupStateTracker* tracker,
62 OffererState event) const {
63 return tracker->NoteOffererStateEvent(event, false);
64 }
65
NoteStateEvent(CallSetupStateTracker * tracker,AnswererState event) const66 bool NoteStateEvent(CallSetupStateTracker* tracker,
67 AnswererState event) const {
68 return tracker->NoteAnswererStateEvent(event, false);
69 }
70
71 template <typename StateType>
VerifyReachability(Reachability reachability,Vector<StateType> states) const72 bool VerifyReachability(Reachability reachability,
73 Vector<StateType> states) const {
74 bool expected_state_reached = (reachability == Reachability::kReachable);
75 for (const auto& state : states) {
76 bool did_reach_state;
77 if (state == current_state<StateType>()) {
78 // The current state always counts as reachable.
79 did_reach_state = true;
80 } else {
81 // Perform the test on a copy to avoid mutating |tracker_|.
82 CallSetupStateTracker tracker_copy = tracker_;
83 did_reach_state = NoteStateEvent(&tracker_copy, state);
84 }
85 if (did_reach_state != expected_state_reached)
86 return false;
87 }
88 return true;
89 }
90
91 template <typename StateType>
VerifyOnlyReachableStates(Vector<StateType> reachable_states,bool include_current=true) const92 bool VerifyOnlyReachableStates(Vector<StateType> reachable_states,
93 bool include_current = true) const {
94 if (include_current)
95 reachable_states.push_back(current_state<StateType>());
96 Vector<StateType> unreachable_states = GetAllCallSetupStates<StateType>();
97 for (const auto& reachable_state : reachable_states) {
98 unreachable_states.erase(std::find(unreachable_states.begin(),
99 unreachable_states.end(),
100 reachable_state));
101 }
102 return VerifyReachability<StateType>(Reachability::kReachable,
103 reachable_states) &&
104 VerifyReachability<StateType>(Reachability::kUnreachable,
105 unreachable_states);
106 }
107
108 protected:
109 CallSetupStateTracker tracker_;
110 };
111
112 // The following two template specializations can be moved to the class
113 // declaration once we officially switch to C++17 (we need C++ DR727 to be
114 // implemented).
115 template <>
current_state() const116 OffererState CallSetupStateTrackerTest::current_state() const {
117 return tracker_.offerer_state();
118 }
119
120 template <>
current_state() const121 AnswererState CallSetupStateTrackerTest::current_state() const {
122 return tracker_.answerer_state();
123 }
124
TEST_F(CallSetupStateTrackerTest,InitialState)125 TEST_F(CallSetupStateTrackerTest, InitialState) {
126 EXPECT_EQ(OffererState::kNotStarted, tracker_.offerer_state());
127 EXPECT_EQ(AnswererState::kNotStarted, tracker_.answerer_state());
128 EXPECT_EQ(CallSetupState::kNotStarted, tracker_.GetCallSetupState());
129 EXPECT_FALSE(tracker_.document_uses_media());
130 }
131
TEST_F(CallSetupStateTrackerTest,OffererSuccessfulNegotiation)132 TEST_F(CallSetupStateTrackerTest, OffererSuccessfulNegotiation) {
133 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
134 {OffererState::kCreateOfferPending}));
135 EXPECT_TRUE(
136 tracker_.NoteOffererStateEvent(OffererState::kCreateOfferPending, false));
137 EXPECT_EQ(OffererState::kCreateOfferPending, tracker_.offerer_state());
138 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
139 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
140 {OffererState::kCreateOfferResolved,
141 OffererState::kCreateOfferRejected}));
142 EXPECT_TRUE(tracker_.NoteOffererStateEvent(OffererState::kCreateOfferResolved,
143 false));
144 EXPECT_EQ(OffererState::kCreateOfferResolved, tracker_.offerer_state());
145 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
146 {OffererState::kSetLocalOfferPending}));
147 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
148 OffererState::kSetLocalOfferPending, false));
149 EXPECT_EQ(OffererState::kSetLocalOfferPending, tracker_.offerer_state());
150 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
151 {OffererState::kSetLocalOfferResolved,
152 OffererState::kSetLocalOfferRejected}));
153 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
154 OffererState::kSetLocalOfferResolved, false));
155 EXPECT_EQ(OffererState::kSetLocalOfferResolved, tracker_.offerer_state());
156 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
157 {OffererState::kSetRemoteAnswerPending}));
158 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
159 OffererState::kSetRemoteAnswerPending, false));
160 EXPECT_EQ(OffererState::kSetRemoteAnswerPending, tracker_.offerer_state());
161 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
162 {OffererState::kSetRemoteAnswerResolved,
163 OffererState::kSetRemoteAnswerRejected}));
164 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
165 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
166 OffererState::kSetRemoteAnswerResolved, false));
167 EXPECT_EQ(OffererState::kSetRemoteAnswerResolved, tracker_.offerer_state());
168 EXPECT_EQ(CallSetupState::kSucceeded, tracker_.GetCallSetupState());
169 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>({}));
170 }
171
TEST_F(CallSetupStateTrackerTest,OffererCreateOfferRejected)172 TEST_F(CallSetupStateTrackerTest, OffererCreateOfferRejected) {
173 EXPECT_TRUE(
174 tracker_.NoteOffererStateEvent(OffererState::kCreateOfferPending, false));
175 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
176 EXPECT_TRUE(tracker_.NoteOffererStateEvent(OffererState::kCreateOfferRejected,
177 false));
178 EXPECT_EQ(OffererState::kCreateOfferRejected, tracker_.offerer_state());
179 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
180 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
181 {OffererState::kCreateOfferResolved}));
182 }
183
TEST_F(CallSetupStateTrackerTest,OffererSetLocalOfferRejected)184 TEST_F(CallSetupStateTrackerTest, OffererSetLocalOfferRejected) {
185 EXPECT_TRUE(
186 tracker_.NoteOffererStateEvent(OffererState::kCreateOfferPending, false));
187 EXPECT_TRUE(tracker_.NoteOffererStateEvent(OffererState::kCreateOfferResolved,
188 false));
189 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
190 OffererState::kSetLocalOfferPending, false));
191 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
192 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
193 OffererState::kSetLocalOfferRejected, false));
194 EXPECT_EQ(OffererState::kSetLocalOfferRejected, tracker_.offerer_state());
195 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
196 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
197 {OffererState::kSetLocalOfferResolved}));
198 }
199
TEST_F(CallSetupStateTrackerTest,OffererSetRemoteAnswerRejected)200 TEST_F(CallSetupStateTrackerTest, OffererSetRemoteAnswerRejected) {
201 EXPECT_TRUE(
202 tracker_.NoteOffererStateEvent(OffererState::kCreateOfferPending, false));
203 EXPECT_TRUE(tracker_.NoteOffererStateEvent(OffererState::kCreateOfferResolved,
204 false));
205 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
206 OffererState::kSetLocalOfferPending, false));
207 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
208 OffererState::kSetLocalOfferResolved, false));
209 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
210 OffererState::kSetRemoteAnswerPending, false));
211 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
212 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
213 OffererState::kSetRemoteAnswerRejected, false));
214 EXPECT_EQ(OffererState::kSetRemoteAnswerRejected, tracker_.offerer_state());
215 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
216 EXPECT_TRUE(VerifyOnlyReachableStates<OffererState>(
217 {OffererState::kSetRemoteAnswerResolved}));
218 }
219
TEST_F(CallSetupStateTrackerTest,OffererRejectThenSucceed)220 TEST_F(CallSetupStateTrackerTest, OffererRejectThenSucceed) {
221 EXPECT_TRUE(
222 tracker_.NoteOffererStateEvent(OffererState::kCreateOfferPending, false));
223 EXPECT_TRUE(tracker_.NoteOffererStateEvent(OffererState::kCreateOfferResolved,
224 false));
225 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
226 OffererState::kSetLocalOfferPending, false));
227 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
228 OffererState::kSetLocalOfferResolved, false));
229 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
230 OffererState::kSetRemoteAnswerPending, false));
231 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
232 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
233 OffererState::kSetRemoteAnswerRejected, false));
234 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
235 // Pending another operation should not revert the states to "pending" or
236 // "started".
237 EXPECT_FALSE(tracker_.NoteOffererStateEvent(
238 OffererState::kSetRemoteAnswerPending, false));
239 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
240 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
241 OffererState::kSetRemoteAnswerResolved, false));
242 EXPECT_EQ(CallSetupState::kSucceeded, tracker_.GetCallSetupState());
243 }
244
TEST_F(CallSetupStateTrackerTest,AnswererSuccessfulNegotiation)245 TEST_F(CallSetupStateTrackerTest, AnswererSuccessfulNegotiation) {
246 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
247 {AnswererState::kSetRemoteOfferPending}));
248 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
249 AnswererState::kSetRemoteOfferPending, false));
250 EXPECT_EQ(AnswererState::kSetRemoteOfferPending, tracker_.answerer_state());
251 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
252 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
253 {AnswererState::kSetRemoteOfferResolved,
254 AnswererState::kSetRemoteOfferRejected}));
255 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
256 AnswererState::kSetRemoteOfferResolved, false));
257 EXPECT_EQ(AnswererState::kSetRemoteOfferResolved, tracker_.answerer_state());
258 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
259 {AnswererState::kCreateAnswerPending}));
260 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
261 AnswererState::kCreateAnswerPending, false));
262 EXPECT_EQ(AnswererState::kCreateAnswerPending, tracker_.answerer_state());
263 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
264 {AnswererState::kCreateAnswerResolved,
265 AnswererState::kCreateAnswerRejected}));
266 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
267 AnswererState::kCreateAnswerResolved, false));
268 EXPECT_EQ(AnswererState::kCreateAnswerResolved, tracker_.answerer_state());
269 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
270 {AnswererState::kSetLocalAnswerPending}));
271 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
272 AnswererState::kSetLocalAnswerPending, false));
273 EXPECT_EQ(AnswererState::kSetLocalAnswerPending, tracker_.answerer_state());
274 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
275 {AnswererState::kSetLocalAnswerResolved,
276 AnswererState::kSetLocalAnswerRejected}));
277 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
278 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
279 AnswererState::kSetLocalAnswerResolved, false));
280 EXPECT_EQ(AnswererState::kSetLocalAnswerResolved, tracker_.answerer_state());
281 EXPECT_EQ(CallSetupState::kSucceeded, tracker_.GetCallSetupState());
282 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>({}));
283 }
284
TEST_F(CallSetupStateTrackerTest,AnswererSetRemoteOfferRejected)285 TEST_F(CallSetupStateTrackerTest, AnswererSetRemoteOfferRejected) {
286 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
287 AnswererState::kSetRemoteOfferPending, false));
288 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
289 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
290 AnswererState::kSetRemoteOfferRejected, false));
291 EXPECT_EQ(AnswererState::kSetRemoteOfferRejected, tracker_.answerer_state());
292 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
293 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
294 {AnswererState::kSetRemoteOfferResolved}));
295 }
296
TEST_F(CallSetupStateTrackerTest,AnswererCreateAnswerRejected)297 TEST_F(CallSetupStateTrackerTest, AnswererCreateAnswerRejected) {
298 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
299 AnswererState::kSetRemoteOfferPending, false));
300 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
301 AnswererState::kSetRemoteOfferResolved, false));
302 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
303 AnswererState::kCreateAnswerPending, false));
304 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
305 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
306 AnswererState::kCreateAnswerRejected, false));
307 EXPECT_EQ(AnswererState::kCreateAnswerRejected, tracker_.answerer_state());
308 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
309 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
310 {AnswererState::kCreateAnswerResolved}));
311 }
312
TEST_F(CallSetupStateTrackerTest,AnswererSetLocalAnswerRejected)313 TEST_F(CallSetupStateTrackerTest, AnswererSetLocalAnswerRejected) {
314 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
315 AnswererState::kSetRemoteOfferPending, false));
316 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
317 AnswererState::kSetRemoteOfferResolved, false));
318 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
319 AnswererState::kCreateAnswerPending, false));
320 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
321 AnswererState::kCreateAnswerResolved, false));
322 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
323 AnswererState::kSetLocalAnswerPending, false));
324 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
325 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
326 AnswererState::kSetLocalAnswerRejected, false));
327 EXPECT_EQ(AnswererState::kSetLocalAnswerRejected, tracker_.answerer_state());
328 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
329 EXPECT_TRUE(VerifyOnlyReachableStates<AnswererState>(
330 {AnswererState::kSetLocalAnswerResolved}));
331 }
332
TEST_F(CallSetupStateTrackerTest,AnswererRejectThenSucceed)333 TEST_F(CallSetupStateTrackerTest, AnswererRejectThenSucceed) {
334 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
335 AnswererState::kSetRemoteOfferPending, false));
336 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
337 AnswererState::kSetRemoteOfferResolved, false));
338 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
339 AnswererState::kCreateAnswerPending, false));
340 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
341 AnswererState::kCreateAnswerResolved, false));
342 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
343 AnswererState::kSetLocalAnswerPending, false));
344 EXPECT_EQ(CallSetupState::kStarted, tracker_.GetCallSetupState());
345 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
346 AnswererState::kSetLocalAnswerRejected, false));
347 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
348 // Pending another operation should not revert the states to "pending" or
349 // "started".
350 EXPECT_FALSE(tracker_.NoteAnswererStateEvent(
351 AnswererState::kSetLocalAnswerPending, false));
352 EXPECT_EQ(CallSetupState::kFailed, tracker_.GetCallSetupState());
353 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
354 AnswererState::kSetLocalAnswerResolved, false));
355 EXPECT_EQ(CallSetupState::kSucceeded, tracker_.GetCallSetupState());
356 }
357
358 // Succeeding in one role and subsequently failing in another should not revert
359 // the call setup state from kSucceeded; the most succeessful attempt would
360 // still have been successful.
TEST_F(CallSetupStateTrackerTest,OffererSucceedAnswererFail)361 TEST_F(CallSetupStateTrackerTest, OffererSucceedAnswererFail) {
362 EXPECT_TRUE(
363 tracker_.NoteOffererStateEvent(OffererState::kCreateOfferPending, false));
364 EXPECT_TRUE(tracker_.NoteOffererStateEvent(OffererState::kCreateOfferResolved,
365 false));
366 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
367 OffererState::kSetLocalOfferPending, false));
368 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
369 OffererState::kSetLocalOfferResolved, false));
370 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
371 OffererState::kSetRemoteAnswerPending, false));
372 EXPECT_TRUE(tracker_.NoteOffererStateEvent(
373 OffererState::kSetRemoteAnswerResolved, false));
374 EXPECT_EQ(CallSetupState::kSucceeded, tracker_.GetCallSetupState());
375 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
376 AnswererState::kSetRemoteOfferPending, false));
377 EXPECT_TRUE(tracker_.NoteAnswererStateEvent(
378 AnswererState::kSetRemoteOfferRejected, false));
379 // Still succeeded.
380 EXPECT_EQ(CallSetupState::kSucceeded, tracker_.GetCallSetupState());
381 }
382
TEST_F(CallSetupStateTrackerTest,SetDocumentMedia)383 TEST_F(CallSetupStateTrackerTest, SetDocumentMedia) {
384 // Any offerer state event can set document_uses_media().
385 for (auto offerer_state : GetAllCallSetupStates<OffererState>()) {
386 CallSetupStateTracker tracker;
387 EXPECT_FALSE(tracker.document_uses_media());
388 tracker.NoteOffererStateEvent(offerer_state, true);
389 EXPECT_TRUE(tracker.document_uses_media());
390 }
391 // Any answerer state event can set document_uses_media().
392 for (auto answerer_state : GetAllCallSetupStates<AnswererState>()) {
393 CallSetupStateTracker tracker;
394 EXPECT_FALSE(tracker.document_uses_media());
395 tracker.NoteAnswererStateEvent(answerer_state, true);
396 EXPECT_TRUE(tracker.document_uses_media());
397 }
398 }
399
TEST_F(CallSetupStateTrackerTest,DocumentMediaCannotBeUnset)400 TEST_F(CallSetupStateTrackerTest, DocumentMediaCannotBeUnset) {
401 tracker_.NoteOffererStateEvent(OffererState::kSetLocalOfferPending, true);
402 EXPECT_TRUE(tracker_.document_uses_media());
403 tracker_.NoteOffererStateEvent(OffererState::kSetLocalOfferResolved, false);
404 // If it has ever been true, it stays true.
405 EXPECT_TRUE(tracker_.document_uses_media());
406 }
407
408 } // namespace blink
409