OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2014, Google Inc. All rights reserved. | 2 * Copyright (c) 2014, Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 13 matching lines...) Expand all Loading... |
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
29 */ | 29 */ |
30 | 30 |
31 #include "core/page/NetworkStateNotifier.h" | 31 #include "core/page/NetworkStateNotifier.h" |
32 | 32 |
33 #include "core/dom/Document.h" | 33 #include "core/dom/Document.h" |
| 34 #include "core/dom/TaskRunnerHelper.h" |
34 #include "platform/testing/UnitTestHelpers.h" | 35 #include "platform/testing/UnitTestHelpers.h" |
35 #include "public/platform/Platform.h" | 36 #include "public/platform/Platform.h" |
36 #include "public/platform/WebConnectionType.h" | 37 #include "public/platform/WebConnectionType.h" |
37 #include "public/platform/WebThread.h" | 38 #include "public/platform/WebThread.h" |
38 #include "testing/gtest/include/gtest/gtest.h" | 39 #include "testing/gtest/include/gtest/gtest.h" |
39 #include "wtf/Functional.h" | 40 #include "wtf/Functional.h" |
40 | 41 |
41 namespace blink { | 42 namespace blink { |
42 | 43 |
43 namespace { | 44 namespace { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
82 | 83 |
83 class NetworkStateNotifierTest : public ::testing::Test { | 84 class NetworkStateNotifierTest : public ::testing::Test { |
84 public: | 85 public: |
85 NetworkStateNotifierTest() | 86 NetworkStateNotifierTest() |
86 : m_document(Document::create()), m_document2(Document::create()) { | 87 : m_document(Document::create()), m_document2(Document::create()) { |
87 // Initialize connection, so that future calls to setWebConnection issue | 88 // Initialize connection, so that future calls to setWebConnection issue |
88 // notifications. | 89 // notifications. |
89 m_notifier.setWebConnection(WebConnectionTypeUnknown, 0.0); | 90 m_notifier.setWebConnection(WebConnectionTypeUnknown, 0.0); |
90 } | 91 } |
91 | 92 |
92 ExecutionContext* getExecutionContext() { return m_document.get(); } | 93 WebTaskRunner* getTaskRunner() { |
| 94 return TaskRunnerHelper::get(TaskType::Networking, m_document.get()).get(); |
| 95 } |
93 | 96 |
94 ExecutionContext* executionContext2() { return m_document2.get(); } | 97 WebTaskRunner* getTaskRunner2() { |
| 98 return TaskRunnerHelper::get(TaskType::Networking, m_document2.get()).get(); |
| 99 } |
95 | 100 |
96 protected: | 101 protected: |
97 void setConnection(WebConnectionType type, double maxBandwidthMbps) { | 102 void setConnection(WebConnectionType type, double maxBandwidthMbps) { |
98 m_notifier.setWebConnection(type, maxBandwidthMbps); | 103 m_notifier.setWebConnection(type, maxBandwidthMbps); |
99 testing::runPendingTasks(); | 104 testing::runPendingTasks(); |
100 } | 105 } |
101 | 106 |
102 void addObserverOnNotification(StateObserver* observer, | 107 void addObserverOnNotification(StateObserver* observer, |
103 StateObserver* observerToAdd) { | 108 StateObserver* observerToAdd) { |
104 observer->setNotificationCallback(bind( | 109 observer->setNotificationCallback( |
105 &NetworkStateNotifier::addObserver, WTF::unretained(&m_notifier), | 110 bind(&NetworkStateNotifier::addObserver, WTF::unretained(&m_notifier), |
106 WTF::unretained(observerToAdd), wrapPersistent(getExecutionContext()))); | 111 WTF::unretained(observerToAdd), WTF::unretained(getTaskRunner()))); |
107 } | 112 } |
108 | 113 |
109 void removeObserverOnNotification(StateObserver* observer, | 114 void removeObserverOnNotification(StateObserver* observer, |
110 StateObserver* observerToRemove) { | 115 StateObserver* observerToRemove) { |
111 observer->setNotificationCallback( | 116 observer->setNotificationCallback(bind( |
112 bind(&NetworkStateNotifier::removeObserver, | 117 &NetworkStateNotifier::removeObserver, WTF::unretained(&m_notifier), |
113 WTF::unretained(&m_notifier), WTF::unretained(observerToRemove), | 118 WTF::unretained(observerToRemove), WTF::unretained(getTaskRunner()))); |
114 wrapPersistent(getExecutionContext()))); | |
115 } | 119 } |
116 | 120 |
117 bool verifyObservations(const StateObserver& observer, | 121 bool verifyObservations(const StateObserver& observer, |
118 WebConnectionType type, | 122 WebConnectionType type, |
119 double maxBandwidthMbps) { | 123 double maxBandwidthMbps) { |
120 EXPECT_EQ(observer.observedType(), type); | 124 EXPECT_EQ(observer.observedType(), type); |
121 EXPECT_EQ(observer.observedMaxBandwidth(), maxBandwidthMbps); | 125 EXPECT_EQ(observer.observedMaxBandwidth(), maxBandwidthMbps); |
122 return observer.observedType() == type && | 126 return observer.observedType() == type && |
123 observer.observedMaxBandwidth() == maxBandwidthMbps; | 127 observer.observedMaxBandwidth() == maxBandwidthMbps; |
124 } | 128 } |
125 | 129 |
126 Persistent<Document> m_document; | 130 Persistent<Document> m_document; |
127 Persistent<Document> m_document2; | 131 Persistent<Document> m_document2; |
128 NetworkStateNotifier m_notifier; | 132 NetworkStateNotifier m_notifier; |
129 }; | 133 }; |
130 | 134 |
131 TEST_F(NetworkStateNotifierTest, AddObserver) { | 135 TEST_F(NetworkStateNotifierTest, AddObserver) { |
132 StateObserver observer; | 136 StateObserver observer; |
133 m_notifier.addObserver(&observer, getExecutionContext()); | 137 m_notifier.addObserver(&observer, getTaskRunner()); |
134 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeNone, | 138 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeNone, |
135 kNoneMaxBandwidthMbps)); | 139 kNoneMaxBandwidthMbps)); |
136 | 140 |
137 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 141 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
138 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, | 142 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, |
139 kBluetoothMaxBandwidthMbps)); | 143 kBluetoothMaxBandwidthMbps)); |
140 EXPECT_EQ(observer.callbackCount(), 1); | 144 EXPECT_EQ(observer.callbackCount(), 1); |
141 } | 145 } |
142 | 146 |
143 TEST_F(NetworkStateNotifierTest, RemoveObserver) { | 147 TEST_F(NetworkStateNotifierTest, RemoveObserver) { |
144 StateObserver observer1, observer2; | 148 StateObserver observer1, observer2; |
145 m_notifier.addObserver(&observer1, getExecutionContext()); | 149 m_notifier.addObserver(&observer1, getTaskRunner()); |
146 m_notifier.removeObserver(&observer1, getExecutionContext()); | 150 m_notifier.removeObserver(&observer1, getTaskRunner()); |
147 m_notifier.addObserver(&observer2, getExecutionContext()); | 151 m_notifier.addObserver(&observer2, getTaskRunner()); |
148 | 152 |
149 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 153 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
150 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeNone, | 154 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeNone, |
151 kNoneMaxBandwidthMbps)); | 155 kNoneMaxBandwidthMbps)); |
152 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, | 156 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, |
153 kBluetoothMaxBandwidthMbps)); | 157 kBluetoothMaxBandwidthMbps)); |
154 } | 158 } |
155 | 159 |
156 TEST_F(NetworkStateNotifierTest, RemoveSoleObserver) { | 160 TEST_F(NetworkStateNotifierTest, RemoveSoleObserver) { |
157 StateObserver observer1; | 161 StateObserver observer1; |
158 m_notifier.addObserver(&observer1, getExecutionContext()); | 162 m_notifier.addObserver(&observer1, getTaskRunner()); |
159 m_notifier.removeObserver(&observer1, getExecutionContext()); | 163 m_notifier.removeObserver(&observer1, getTaskRunner()); |
160 | 164 |
161 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 165 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
162 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeNone, | 166 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeNone, |
163 kNoneMaxBandwidthMbps)); | 167 kNoneMaxBandwidthMbps)); |
164 } | 168 } |
165 | 169 |
166 TEST_F(NetworkStateNotifierTest, AddObserverWhileNotifying) { | 170 TEST_F(NetworkStateNotifierTest, AddObserverWhileNotifying) { |
167 StateObserver observer1, observer2; | 171 StateObserver observer1, observer2; |
168 m_notifier.addObserver(&observer1, getExecutionContext()); | 172 m_notifier.addObserver(&observer1, getTaskRunner()); |
169 addObserverOnNotification(&observer1, &observer2); | 173 addObserverOnNotification(&observer1, &observer2); |
170 | 174 |
171 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 175 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
172 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 176 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
173 kBluetoothMaxBandwidthMbps)); | 177 kBluetoothMaxBandwidthMbps)); |
174 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, | 178 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, |
175 kBluetoothMaxBandwidthMbps)); | 179 kBluetoothMaxBandwidthMbps)); |
176 } | 180 } |
177 | 181 |
178 TEST_F(NetworkStateNotifierTest, RemoveSoleObserverWhileNotifying) { | 182 TEST_F(NetworkStateNotifierTest, RemoveSoleObserverWhileNotifying) { |
179 StateObserver observer1; | 183 StateObserver observer1; |
180 m_notifier.addObserver(&observer1, getExecutionContext()); | 184 m_notifier.addObserver(&observer1, getTaskRunner()); |
181 removeObserverOnNotification(&observer1, &observer1); | 185 removeObserverOnNotification(&observer1, &observer1); |
182 | 186 |
183 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 187 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
184 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 188 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
185 kBluetoothMaxBandwidthMbps)); | 189 kBluetoothMaxBandwidthMbps)); |
186 | 190 |
187 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); | 191 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); |
188 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 192 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
189 kBluetoothMaxBandwidthMbps)); | 193 kBluetoothMaxBandwidthMbps)); |
190 } | 194 } |
191 | 195 |
192 TEST_F(NetworkStateNotifierTest, RemoveCurrentObserverWhileNotifying) { | 196 TEST_F(NetworkStateNotifierTest, RemoveCurrentObserverWhileNotifying) { |
193 StateObserver observer1, observer2; | 197 StateObserver observer1, observer2; |
194 m_notifier.addObserver(&observer1, getExecutionContext()); | 198 m_notifier.addObserver(&observer1, getTaskRunner()); |
195 m_notifier.addObserver(&observer2, getExecutionContext()); | 199 m_notifier.addObserver(&observer2, getTaskRunner()); |
196 removeObserverOnNotification(&observer1, &observer1); | 200 removeObserverOnNotification(&observer1, &observer1); |
197 | 201 |
198 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 202 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
199 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 203 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
200 kBluetoothMaxBandwidthMbps)); | 204 kBluetoothMaxBandwidthMbps)); |
201 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, | 205 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, |
202 kBluetoothMaxBandwidthMbps)); | 206 kBluetoothMaxBandwidthMbps)); |
203 | 207 |
204 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); | 208 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); |
205 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 209 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
206 kBluetoothMaxBandwidthMbps)); | 210 kBluetoothMaxBandwidthMbps)); |
207 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeEthernet, | 211 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeEthernet, |
208 kEthernetMaxBandwidthMbps)); | 212 kEthernetMaxBandwidthMbps)); |
209 } | 213 } |
210 | 214 |
211 TEST_F(NetworkStateNotifierTest, RemovePastObserverWhileNotifying) { | 215 TEST_F(NetworkStateNotifierTest, RemovePastObserverWhileNotifying) { |
212 StateObserver observer1, observer2; | 216 StateObserver observer1, observer2; |
213 m_notifier.addObserver(&observer1, getExecutionContext()); | 217 m_notifier.addObserver(&observer1, getTaskRunner()); |
214 m_notifier.addObserver(&observer2, getExecutionContext()); | 218 m_notifier.addObserver(&observer2, getTaskRunner()); |
215 removeObserverOnNotification(&observer2, &observer1); | 219 removeObserverOnNotification(&observer2, &observer1); |
216 | 220 |
217 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 221 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
218 EXPECT_EQ(observer1.observedType(), WebConnectionTypeBluetooth); | 222 EXPECT_EQ(observer1.observedType(), WebConnectionTypeBluetooth); |
219 EXPECT_EQ(observer2.observedType(), WebConnectionTypeBluetooth); | 223 EXPECT_EQ(observer2.observedType(), WebConnectionTypeBluetooth); |
220 | 224 |
221 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); | 225 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); |
222 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 226 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
223 kBluetoothMaxBandwidthMbps)); | 227 kBluetoothMaxBandwidthMbps)); |
224 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeEthernet, | 228 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeEthernet, |
225 kEthernetMaxBandwidthMbps)); | 229 kEthernetMaxBandwidthMbps)); |
226 } | 230 } |
227 | 231 |
228 TEST_F(NetworkStateNotifierTest, RemoveFutureObserverWhileNotifying) { | 232 TEST_F(NetworkStateNotifierTest, RemoveFutureObserverWhileNotifying) { |
229 StateObserver observer1, observer2, observer3; | 233 StateObserver observer1, observer2, observer3; |
230 m_notifier.addObserver(&observer1, getExecutionContext()); | 234 m_notifier.addObserver(&observer1, getTaskRunner()); |
231 m_notifier.addObserver(&observer2, getExecutionContext()); | 235 m_notifier.addObserver(&observer2, getTaskRunner()); |
232 m_notifier.addObserver(&observer3, getExecutionContext()); | 236 m_notifier.addObserver(&observer3, getTaskRunner()); |
233 removeObserverOnNotification(&observer1, &observer2); | 237 removeObserverOnNotification(&observer1, &observer2); |
234 | 238 |
235 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 239 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
236 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 240 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
237 kBluetoothMaxBandwidthMbps)); | 241 kBluetoothMaxBandwidthMbps)); |
238 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeNone, | 242 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeNone, |
239 kNoneMaxBandwidthMbps)); | 243 kNoneMaxBandwidthMbps)); |
240 EXPECT_TRUE(verifyObservations(observer3, WebConnectionTypeBluetooth, | 244 EXPECT_TRUE(verifyObservations(observer3, WebConnectionTypeBluetooth, |
241 kBluetoothMaxBandwidthMbps)); | 245 kBluetoothMaxBandwidthMbps)); |
242 } | 246 } |
243 | 247 |
244 TEST_F(NetworkStateNotifierTest, MultipleContextsAddObserver) { | 248 TEST_F(NetworkStateNotifierTest, MultipleContextsAddObserver) { |
245 StateObserver observer1, observer2; | 249 StateObserver observer1, observer2; |
246 m_notifier.addObserver(&observer1, getExecutionContext()); | 250 m_notifier.addObserver(&observer1, getTaskRunner()); |
247 m_notifier.addObserver(&observer2, executionContext2()); | 251 m_notifier.addObserver(&observer2, getTaskRunner2()); |
248 | 252 |
249 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 253 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
250 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 254 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
251 kBluetoothMaxBandwidthMbps)); | 255 kBluetoothMaxBandwidthMbps)); |
252 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, | 256 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeBluetooth, |
253 kBluetoothMaxBandwidthMbps)); | 257 kBluetoothMaxBandwidthMbps)); |
254 } | 258 } |
255 | 259 |
256 TEST_F(NetworkStateNotifierTest, RemoveContext) { | 260 TEST_F(NetworkStateNotifierTest, RemoveContext) { |
257 StateObserver observer1, observer2; | 261 StateObserver observer1, observer2; |
258 m_notifier.addObserver(&observer1, getExecutionContext()); | 262 m_notifier.addObserver(&observer1, getTaskRunner()); |
259 m_notifier.addObserver(&observer2, executionContext2()); | 263 m_notifier.addObserver(&observer2, getTaskRunner2()); |
260 m_notifier.removeObserver(&observer2, executionContext2()); | 264 m_notifier.removeObserver(&observer2, getTaskRunner2()); |
261 | 265 |
262 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 266 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
263 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, | 267 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeBluetooth, |
264 kBluetoothMaxBandwidthMbps)); | 268 kBluetoothMaxBandwidthMbps)); |
265 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeNone, | 269 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeNone, |
266 kNoneMaxBandwidthMbps)); | 270 kNoneMaxBandwidthMbps)); |
267 } | 271 } |
268 | 272 |
269 TEST_F(NetworkStateNotifierTest, RemoveAllContexts) { | 273 TEST_F(NetworkStateNotifierTest, RemoveAllContexts) { |
270 StateObserver observer1, observer2; | 274 StateObserver observer1, observer2; |
271 m_notifier.addObserver(&observer1, getExecutionContext()); | 275 m_notifier.addObserver(&observer1, getTaskRunner()); |
272 m_notifier.addObserver(&observer2, executionContext2()); | 276 m_notifier.addObserver(&observer2, getTaskRunner2()); |
273 m_notifier.removeObserver(&observer1, getExecutionContext()); | 277 m_notifier.removeObserver(&observer1, getTaskRunner()); |
274 m_notifier.removeObserver(&observer2, executionContext2()); | 278 m_notifier.removeObserver(&observer2, getTaskRunner2()); |
275 | 279 |
276 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 280 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
277 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeNone, | 281 EXPECT_TRUE(verifyObservations(observer1, WebConnectionTypeNone, |
278 kNoneMaxBandwidthMbps)); | 282 kNoneMaxBandwidthMbps)); |
279 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeNone, | 283 EXPECT_TRUE(verifyObservations(observer2, WebConnectionTypeNone, |
280 kNoneMaxBandwidthMbps)); | 284 kNoneMaxBandwidthMbps)); |
281 } | 285 } |
282 | 286 |
283 TEST_F(NetworkStateNotifierTest, SetOverride) { | 287 TEST_F(NetworkStateNotifierTest, SetOverride) { |
284 StateObserver observer; | 288 StateObserver observer; |
285 m_notifier.addObserver(&observer, getExecutionContext()); | 289 m_notifier.addObserver(&observer, getTaskRunner()); |
286 | 290 |
287 m_notifier.setOnLine(true); | 291 m_notifier.setOnLine(true); |
288 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 292 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
289 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, | 293 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, |
290 kBluetoothMaxBandwidthMbps)); | 294 kBluetoothMaxBandwidthMbps)); |
291 EXPECT_TRUE(m_notifier.onLine()); | 295 EXPECT_TRUE(m_notifier.onLine()); |
292 EXPECT_EQ(WebConnectionTypeBluetooth, m_notifier.connectionType()); | 296 EXPECT_EQ(WebConnectionTypeBluetooth, m_notifier.connectionType()); |
293 EXPECT_EQ(kBluetoothMaxBandwidthMbps, m_notifier.maxBandwidth()); | 297 EXPECT_EQ(kBluetoothMaxBandwidthMbps, m_notifier.maxBandwidth()); |
294 | 298 |
295 m_notifier.setOverride(true, WebConnectionTypeEthernet, | 299 m_notifier.setOverride(true, WebConnectionTypeEthernet, |
(...skipping 17 matching lines...) Expand all Loading... |
313 EXPECT_EQ(kEthernetMaxBandwidthMbps, m_notifier.maxBandwidth()); | 317 EXPECT_EQ(kEthernetMaxBandwidthMbps, m_notifier.maxBandwidth()); |
314 | 318 |
315 m_notifier.clearOverride(); | 319 m_notifier.clearOverride(); |
316 testing::runPendingTasks(); | 320 testing::runPendingTasks(); |
317 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeNone, | 321 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeNone, |
318 kNoneMaxBandwidthMbps)); | 322 kNoneMaxBandwidthMbps)); |
319 EXPECT_FALSE(m_notifier.onLine()); | 323 EXPECT_FALSE(m_notifier.onLine()); |
320 EXPECT_EQ(WebConnectionTypeNone, m_notifier.connectionType()); | 324 EXPECT_EQ(WebConnectionTypeNone, m_notifier.connectionType()); |
321 EXPECT_EQ(kNoneMaxBandwidthMbps, m_notifier.maxBandwidth()); | 325 EXPECT_EQ(kNoneMaxBandwidthMbps, m_notifier.maxBandwidth()); |
322 | 326 |
323 m_notifier.removeObserver(&observer, getExecutionContext()); | 327 m_notifier.removeObserver(&observer, getTaskRunner()); |
324 } | 328 } |
325 | 329 |
326 TEST_F(NetworkStateNotifierTest, NoExtraNotifications) { | 330 TEST_F(NetworkStateNotifierTest, NoExtraNotifications) { |
327 StateObserver observer; | 331 StateObserver observer; |
328 m_notifier.addObserver(&observer, getExecutionContext()); | 332 m_notifier.addObserver(&observer, getTaskRunner()); |
329 | 333 |
330 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 334 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
331 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, | 335 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, |
332 kBluetoothMaxBandwidthMbps)); | 336 kBluetoothMaxBandwidthMbps)); |
333 EXPECT_EQ(observer.callbackCount(), 1); | 337 EXPECT_EQ(observer.callbackCount(), 1); |
334 | 338 |
335 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 339 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
336 EXPECT_EQ(observer.callbackCount(), 1); | 340 EXPECT_EQ(observer.callbackCount(), 1); |
337 | 341 |
338 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); | 342 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); |
339 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeEthernet, | 343 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeEthernet, |
340 kEthernetMaxBandwidthMbps)); | 344 kEthernetMaxBandwidthMbps)); |
341 EXPECT_EQ(observer.callbackCount(), 2); | 345 EXPECT_EQ(observer.callbackCount(), 2); |
342 | 346 |
343 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); | 347 setConnection(WebConnectionTypeEthernet, kEthernetMaxBandwidthMbps); |
344 EXPECT_EQ(observer.callbackCount(), 2); | 348 EXPECT_EQ(observer.callbackCount(), 2); |
345 | 349 |
346 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); | 350 setConnection(WebConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps); |
347 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, | 351 EXPECT_TRUE(verifyObservations(observer, WebConnectionTypeBluetooth, |
348 kBluetoothMaxBandwidthMbps)); | 352 kBluetoothMaxBandwidthMbps)); |
349 EXPECT_EQ(observer.callbackCount(), 3); | 353 EXPECT_EQ(observer.callbackCount(), 3); |
350 | 354 |
351 m_notifier.removeObserver(&observer, getExecutionContext()); | 355 m_notifier.removeObserver(&observer, getTaskRunner()); |
352 } | 356 } |
353 | 357 |
354 TEST_F(NetworkStateNotifierTest, NoNotificationOnInitialization) { | 358 TEST_F(NetworkStateNotifierTest, NoNotificationOnInitialization) { |
355 NetworkStateNotifier notifier; | 359 NetworkStateNotifier notifier; |
356 Persistent<Document> document(Document::create()); | 360 Persistent<Document> document(Document::create()); |
357 StateObserver observer; | 361 StateObserver observer; |
358 | 362 |
359 notifier.addObserver(&observer, document.get()); | 363 notifier.addObserver(&observer, getTaskRunner()); |
360 testing::runPendingTasks(); | 364 testing::runPendingTasks(); |
361 EXPECT_EQ(observer.callbackCount(), 0); | 365 EXPECT_EQ(observer.callbackCount(), 0); |
362 | 366 |
363 notifier.setWebConnection(WebConnectionTypeBluetooth, | 367 notifier.setWebConnection(WebConnectionTypeBluetooth, |
364 kBluetoothMaxBandwidthMbps); | 368 kBluetoothMaxBandwidthMbps); |
365 testing::runPendingTasks(); | 369 testing::runPendingTasks(); |
366 EXPECT_EQ(observer.callbackCount(), 0); | 370 EXPECT_EQ(observer.callbackCount(), 0); |
367 | 371 |
368 notifier.setWebConnection(WebConnectionTypeBluetooth, | 372 notifier.setWebConnection(WebConnectionTypeBluetooth, |
369 kBluetoothMaxBandwidthMbps); | 373 kBluetoothMaxBandwidthMbps); |
370 testing::runPendingTasks(); | 374 testing::runPendingTasks(); |
371 EXPECT_EQ(observer.callbackCount(), 0); | 375 EXPECT_EQ(observer.callbackCount(), 0); |
372 | 376 |
373 notifier.setWebConnection(WebConnectionTypeEthernet, | 377 notifier.setWebConnection(WebConnectionTypeEthernet, |
374 kEthernetMaxBandwidthMbps); | 378 kEthernetMaxBandwidthMbps); |
375 testing::runPendingTasks(); | 379 testing::runPendingTasks(); |
376 EXPECT_EQ(observer.callbackCount(), 1); | 380 EXPECT_EQ(observer.callbackCount(), 1); |
377 EXPECT_EQ(observer.observedType(), WebConnectionTypeEthernet); | 381 EXPECT_EQ(observer.observedType(), WebConnectionTypeEthernet); |
378 EXPECT_EQ(observer.observedMaxBandwidth(), kEthernetMaxBandwidthMbps); | 382 EXPECT_EQ(observer.observedMaxBandwidth(), kEthernetMaxBandwidthMbps); |
379 } | 383 } |
380 | 384 |
381 } // namespace blink | 385 } // namespace blink |
OLD | NEW |