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