OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_server_properties_impl.h" | 5 #include "net/http/http_server_properties_impl.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/basictypes.h" | 10 #include "base/basictypes.h" |
(...skipping 219 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
230 ASSERT_EQ(spdy_server_g, string_value_g); | 230 ASSERT_EQ(spdy_server_g, string_value_g); |
231 ASSERT_TRUE(spdy_server_list.GetString(1, &string_value_m)); | 231 ASSERT_TRUE(spdy_server_list.GetString(1, &string_value_m)); |
232 ASSERT_EQ(spdy_server_m, string_value_m); | 232 ASSERT_EQ(spdy_server_m, string_value_m); |
233 } | 233 } |
234 | 234 |
235 typedef HttpServerPropertiesImplTest AlternateProtocolServerPropertiesTest; | 235 typedef HttpServerPropertiesImplTest AlternateProtocolServerPropertiesTest; |
236 | 236 |
237 TEST_F(AlternateProtocolServerPropertiesTest, Basic) { | 237 TEST_F(AlternateProtocolServerPropertiesTest, Basic) { |
238 HostPortPair test_host_port_pair("foo", 80); | 238 HostPortPair test_host_port_pair("foo", 80); |
239 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 239 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
240 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); | 240 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); |
241 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 241 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
242 const AlternateProtocolInfo alternate = | 242 const AlternateProtocols alternate_protocols = |
243 impl_.GetAlternateProtocol(test_host_port_pair); | 243 impl_.GetAlternateProtocols(test_host_port_pair); |
| 244 ASSERT_EQ(1u, alternate_protocols.size()); |
| 245 const AlternateProtocolInfo alternate = alternate_protocols[0]; |
244 EXPECT_EQ(443, alternate.port); | 246 EXPECT_EQ(443, alternate.port); |
245 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 247 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); |
246 | 248 |
247 impl_.Clear(); | 249 impl_.Clear(); |
248 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 250 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
249 } | 251 } |
250 | 252 |
251 TEST_F(AlternateProtocolServerPropertiesTest, DefaultProbabilityExcluded) { | 253 TEST_F(AlternateProtocolServerPropertiesTest, DefaultProbabilityExcluded) { |
252 HostPortPair test_host_port_pair("foo", 80); | 254 HostPortPair test_host_port_pair("foo", 80); |
253 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .99); | 255 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .99); |
254 | 256 |
255 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 257 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
256 } | 258 } |
257 | 259 |
258 TEST_F(AlternateProtocolServerPropertiesTest, Probability) { | 260 TEST_F(AlternateProtocolServerPropertiesTest, Probability) { |
259 impl_.SetAlternateProtocolProbabilityThreshold(.25); | 261 impl_.SetAlternateProtocolProbabilityThreshold(.25); |
260 | 262 |
261 HostPortPair test_host_port_pair("foo", 80); | 263 HostPortPair test_host_port_pair("foo", 80); |
262 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); | 264 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); |
263 | 265 |
264 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 266 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
265 const AlternateProtocolInfo alternate = | 267 const AlternateProtocols alternate_protocols = |
266 impl_.GetAlternateProtocol(test_host_port_pair); | 268 impl_.GetAlternateProtocols(test_host_port_pair); |
| 269 ASSERT_EQ(1u, alternate_protocols.size()); |
| 270 const AlternateProtocolInfo alternate = alternate_protocols[0]; |
267 EXPECT_EQ(443, alternate.port); | 271 EXPECT_EQ(443, alternate.port); |
268 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 272 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); |
269 EXPECT_EQ(.5, alternate.probability); | 273 EXPECT_EQ(.5, alternate.probability); |
270 } | 274 } |
271 | 275 |
272 TEST_F(AlternateProtocolServerPropertiesTest, ProbabilityExcluded) { | 276 TEST_F(AlternateProtocolServerPropertiesTest, ProbabilityExcluded) { |
273 impl_.SetAlternateProtocolProbabilityThreshold(.75); | 277 impl_.SetAlternateProtocolProbabilityThreshold(.75); |
274 | 278 |
275 HostPortPair test_host_port_pair("foo", 80); | 279 HostPortPair test_host_port_pair("foo", 80); |
276 | 280 |
277 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); | 281 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); |
278 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 282 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
279 } | 283 } |
280 | 284 |
281 TEST_F(AlternateProtocolServerPropertiesTest, Initialize) { | 285 TEST_F(AlternateProtocolServerPropertiesTest, Initialize) { |
282 HostPortPair test_host_port_pair1("foo1", 80); | 286 HostPortPair test_host_port_pair1("foo1", 80); |
283 impl_.SetAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); | 287 impl_.AddAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); |
284 impl_.SetBrokenAlternateProtocol(test_host_port_pair1); | 288 impl_.AddAlternateProtocol(test_host_port_pair1, 123, NPN_SPDY_3, 1); |
| 289 AlternateProtocolInfo alternate_protocol(123, NPN_SPDY_3, 1); |
| 290 impl_.SetBrokenAlternateProtocol(test_host_port_pair1, alternate_protocol); |
285 HostPortPair test_host_port_pair2("foo2", 80); | 291 HostPortPair test_host_port_pair2("foo2", 80); |
286 impl_.SetAlternateProtocol(test_host_port_pair2, 443, NPN_SPDY_3, 1); | 292 impl_.AddAlternateProtocol(test_host_port_pair2, 443, NPN_SPDY_3, 1); |
287 | 293 |
288 AlternateProtocolMap alternate_protocol_map( | 294 AlternateProtocolMap alternate_protocol_map( |
289 AlternateProtocolMap::NO_AUTO_EVICT); | 295 AlternateProtocolMap::NO_AUTO_EVICT); |
290 AlternateProtocolInfo alternate(123, NPN_SPDY_3, 1); | 296 AlternateProtocolInfo alternate(123, NPN_SPDY_3, 1); |
291 alternate_protocol_map.Put(test_host_port_pair2, alternate); | 297 alternate_protocol_map.Put(test_host_port_pair2, |
| 298 AlternateProtocols(/*size=*/1, alternate)); |
292 HostPortPair test_host_port_pair3("foo3", 80); | 299 HostPortPair test_host_port_pair3("foo3", 80); |
293 alternate.port = 1234; | 300 alternate.port = 1234; |
294 alternate_protocol_map.Put(test_host_port_pair3, alternate); | 301 alternate_protocol_map.Put(test_host_port_pair3, |
| 302 AlternateProtocols(/*size=*/1, alternate)); |
295 impl_.InitializeAlternateProtocolServers(&alternate_protocol_map); | 303 impl_.InitializeAlternateProtocolServers(&alternate_protocol_map); |
296 | 304 |
297 // Verify test_host_port_pair3 is the MRU server. | 305 // Verify test_host_port_pair3 is the MRU server. |
298 const AlternateProtocolMap& map = impl_.alternate_protocol_map(); | 306 const AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
299 AlternateProtocolMap::const_iterator it = map.begin(); | 307 AlternateProtocolMap::const_iterator it = map.begin(); |
300 it = map.begin(); | |
301 EXPECT_TRUE(it->first.Equals(test_host_port_pair3)); | 308 EXPECT_TRUE(it->first.Equals(test_host_port_pair3)); |
302 EXPECT_EQ(1234, it->second.port); | 309 ASSERT_EQ(1u, it->second.size()); |
303 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 310 EXPECT_EQ(1234, it->second[0].port); |
| 311 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); |
304 | 312 |
305 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); | 313 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); |
306 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair2)); | 314 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair2)); |
307 alternate = impl_.GetAlternateProtocol(test_host_port_pair1); | 315 AlternateProtocols alternate_protocols = |
308 EXPECT_TRUE(alternate.is_broken); | 316 impl_.GetAlternateProtocols(test_host_port_pair1); |
309 alternate = impl_.GetAlternateProtocol(test_host_port_pair2); | 317 ASSERT_EQ(1u, alternate_protocols.size()); |
310 EXPECT_EQ(123, alternate.port); | 318 EXPECT_TRUE(alternate_protocols[0].is_broken); |
311 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 319 alternate_protocols = impl_.GetAlternateProtocols(test_host_port_pair2); |
| 320 ASSERT_EQ(1u, alternate_protocols.size()); |
| 321 EXPECT_EQ(123, alternate_protocols[0].port); |
| 322 EXPECT_EQ(NPN_SPDY_3, alternate_protocols[0].protocol); |
312 } | 323 } |
313 | 324 |
314 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfHasAlternateProtocol) { | 325 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfHasAlternateProtocol) { |
315 HostPortPair test_host_port_pair1("foo1", 80); | 326 HostPortPair test_host_port_pair1("foo1", 80); |
316 impl_.SetAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); | 327 impl_.AddAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); |
317 HostPortPair test_host_port_pair2("foo2", 80); | 328 HostPortPair test_host_port_pair2("foo2", 80); |
318 impl_.SetAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); | 329 impl_.AddAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); |
319 | 330 |
320 const AlternateProtocolMap& map = impl_.alternate_protocol_map(); | 331 const AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
321 AlternateProtocolMap::const_iterator it = map.begin(); | 332 AlternateProtocolMap::const_iterator it = map.begin(); |
322 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); | 333 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); |
323 EXPECT_EQ(1234, it->second.port); | 334 ASSERT_EQ(1u, it->second.size()); |
324 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 335 EXPECT_EQ(1234, it->second[0].port); |
| 336 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); |
325 | 337 |
326 // HasAlternateProtocol should reoder the AlternateProtocol map. | 338 // HasAlternateProtocol should reoder the AlternateProtocol map. |
327 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); | 339 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); |
328 it = map.begin(); | 340 it = map.begin(); |
329 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); | 341 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); |
330 EXPECT_EQ(443, it->second.port); | 342 ASSERT_EQ(1u, it->second.size()); |
331 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 343 EXPECT_EQ(443, it->second[0].port); |
| 344 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); |
332 } | 345 } |
333 | 346 |
334 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfGetAlternateProtocol) { | 347 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfGetAlternateProtocol) { |
335 HostPortPair test_host_port_pair1("foo1", 80); | 348 HostPortPair test_host_port_pair1("foo1", 80); |
336 impl_.SetAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); | 349 impl_.AddAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); |
337 HostPortPair test_host_port_pair2("foo2", 80); | 350 HostPortPair test_host_port_pair2("foo2", 80); |
338 impl_.SetAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); | 351 impl_.AddAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); |
339 | 352 |
340 const AlternateProtocolMap& map = impl_.alternate_protocol_map(); | 353 const AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
341 AlternateProtocolMap::const_iterator it = map.begin(); | 354 AlternateProtocolMap::const_iterator it = map.begin(); |
342 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); | 355 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); |
343 EXPECT_EQ(1234, it->second.port); | 356 ASSERT_EQ(1u, it->second.size()); |
344 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 357 EXPECT_EQ(1234, it->second[0].port); |
| 358 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); |
345 | 359 |
346 // GetAlternateProtocol should reoder the AlternateProtocol map. | 360 // GetAlternateProtocols should reorder the AlternateProtocol map. |
347 AlternateProtocolInfo alternate = | 361 const AlternateProtocols alternate_protocols = |
348 impl_.GetAlternateProtocol(test_host_port_pair1); | 362 impl_.GetAlternateProtocols(test_host_port_pair1); |
| 363 ASSERT_EQ(1u, alternate_protocols.size()); |
| 364 const AlternateProtocolInfo alternate = alternate_protocols[0]; |
349 EXPECT_EQ(443, alternate.port); | 365 EXPECT_EQ(443, alternate.port); |
350 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 366 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); |
351 it = map.begin(); | 367 it = map.begin(); |
352 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); | 368 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); |
353 EXPECT_EQ(443, it->second.port); | 369 ASSERT_EQ(1u, it->second.size()); |
354 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 370 EXPECT_EQ(443, it->second[0].port); |
| 371 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); |
| 372 } |
| 373 |
| 374 TEST_F(AlternateProtocolServerPropertiesTest, RemoveForSingleHost) { |
| 375 HostPortPair test_host_port_pair("foo", 80); |
| 376 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); |
| 377 impl_.AddAlternateProtocol(test_host_port_pair, 1234, NPN_SPDY_3, 1); |
| 378 |
| 379 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
| 380 net::AlternateProtocolMap::const_iterator it = map.begin(); |
| 381 EXPECT_TRUE(it->first.Equals(test_host_port_pair)); |
| 382 ASSERT_EQ(2u, it->second.size()); |
| 383 EXPECT_EQ(443, it->second[0].port); |
| 384 EXPECT_EQ(1234, it->second[1].port); |
| 385 |
| 386 // Adding an identical entry does nothing. |
| 387 impl_.AddAlternateProtocol(test_host_port_pair, 1234, NPN_SPDY_3, 1); |
| 388 it = map.begin(); |
| 389 ASSERT_EQ(2u, it->second.size()); |
| 390 |
| 391 // Add a third one. |
| 392 impl_.AddAlternateProtocol(test_host_port_pair, 123, NPN_SPDY_3, 1); |
| 393 it = map.begin(); |
| 394 ASSERT_EQ(3u, it->second.size()); |
| 395 EXPECT_EQ(123, it->second[2].port); |
| 396 |
| 397 // Remove one by one. |
| 398 impl_.RemoveAlternateProtocol(test_host_port_pair, |
| 399 AlternateProtocolInfo(1234, NPN_SPDY_3, 1)); |
| 400 it = map.begin(); |
| 401 ASSERT_EQ(2u, it->second.size()); |
| 402 EXPECT_EQ(443, it->second[0].port); |
| 403 EXPECT_EQ(123, it->second[1].port); |
| 404 |
| 405 impl_.RemoveAlternateProtocol(test_host_port_pair, |
| 406 AlternateProtocolInfo(443, NPN_SPDY_3, 1)); |
| 407 it = map.begin(); |
| 408 ASSERT_EQ(1u, it->second.size()); |
| 409 EXPECT_EQ(123, it->second[0].port); |
| 410 |
| 411 impl_.RemoveAlternateProtocol(test_host_port_pair, |
| 412 AlternateProtocolInfo(123, NPN_SPDY_3, 1)); |
| 413 ASSERT_EQ(0u, impl_.alternate_protocol_map().size()); |
| 414 } |
| 415 |
| 416 TEST_F(AlternateProtocolServerPropertiesTest, ClearAlternateProtocol) { |
| 417 HostPortPair test_host_port_pair("foo", 80); |
| 418 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); |
| 419 impl_.AddAlternateProtocol(test_host_port_pair, 1234, NPN_SPDY_3, 1); |
| 420 |
| 421 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
| 422 net::AlternateProtocolMap::const_iterator it = map.begin(); |
| 423 EXPECT_TRUE(it->first.Equals(test_host_port_pair)); |
| 424 ASSERT_EQ(2u, it->second.size()); |
| 425 EXPECT_EQ(443, it->second[0].port); |
| 426 EXPECT_EQ(1234, it->second[1].port); |
| 427 |
| 428 impl_.ClearAlternateProtocol(test_host_port_pair); |
| 429 ASSERT_EQ(0u, impl_.alternate_protocol_map().size()); |
355 } | 430 } |
356 | 431 |
357 TEST_F(AlternateProtocolServerPropertiesTest, SetBroken) { | 432 TEST_F(AlternateProtocolServerPropertiesTest, SetBroken) { |
358 HostPortPair test_host_port_pair("foo", 80); | 433 HostPortPair test_host_port_pair("foo", 80); |
359 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); | 434 impl_.AddAlternateProtocol(test_host_port_pair, 123, NPN_SPDY_3, 1); |
360 impl_.SetBrokenAlternateProtocol(test_host_port_pair); | 435 AlternateProtocolInfo alternate(123, NPN_SPDY_3, 1); |
| 436 impl_.SetBrokenAlternateProtocol(test_host_port_pair, alternate); |
361 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 437 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
362 AlternateProtocolInfo alternate = | 438 AlternateProtocols alternate_protocols = |
363 impl_.GetAlternateProtocol(test_host_port_pair); | 439 impl_.GetAlternateProtocols(test_host_port_pair); |
364 EXPECT_TRUE(alternate.is_broken); | 440 ASSERT_EQ(1u, alternate_protocols.size()); |
| 441 EXPECT_TRUE(alternate_protocols[0].is_broken); |
365 | 442 |
366 impl_.SetAlternateProtocol( | 443 impl_.AddAlternateProtocol(test_host_port_pair, 123, NPN_SPDY_3, 1); |
367 test_host_port_pair, | 444 alternate_protocols = impl_.GetAlternateProtocols(test_host_port_pair); |
368 1234, | 445 ASSERT_EQ(1u, alternate_protocols.size()) |
369 NPN_SPDY_3, | 446 << "Second attempt should be ignored."; |
370 1); | 447 EXPECT_TRUE(alternate_protocols[0].is_broken); |
371 alternate = impl_.GetAlternateProtocol(test_host_port_pair); | 448 |
372 EXPECT_TRUE(alternate.is_broken) << "Second attempt should be ignored."; | 449 impl_.AddAlternateProtocol(test_host_port_pair, 1234, NPN_SPDY_3, 1); |
| 450 alternate_protocols = impl_.GetAlternateProtocols(test_host_port_pair); |
| 451 ASSERT_EQ(2u, alternate_protocols.size()) << "Different port should be fine."; |
373 } | 452 } |
374 | 453 |
375 TEST_F(AlternateProtocolServerPropertiesTest, ClearBroken) { | 454 TEST_F(AlternateProtocolServerPropertiesTest, ClearBroken) { |
376 HostPortPair test_host_port_pair("foo", 80); | 455 HostPortPair test_host_port_pair("foo", 80); |
377 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); | 456 impl_.AddAlternateProtocol(test_host_port_pair, 123, NPN_SPDY_3, 1); |
378 impl_.SetBrokenAlternateProtocol(test_host_port_pair); | 457 AlternateProtocolInfo alternate(123, NPN_SPDY_3, 1); |
| 458 impl_.SetBrokenAlternateProtocol(test_host_port_pair, alternate); |
379 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 459 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
380 AlternateProtocolInfo alternate = | 460 AlternateProtocols alternate_protocols = |
381 impl_.GetAlternateProtocol(test_host_port_pair); | 461 impl_.GetAlternateProtocols(test_host_port_pair); |
382 EXPECT_TRUE(alternate.is_broken); | 462 ASSERT_EQ(1u, alternate_protocols.size()); |
| 463 EXPECT_TRUE(alternate_protocols[0].is_broken); |
383 impl_.ClearAlternateProtocol(test_host_port_pair); | 464 impl_.ClearAlternateProtocol(test_host_port_pair); |
384 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 465 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
385 } | 466 } |
386 | 467 |
387 TEST_F(AlternateProtocolServerPropertiesTest, Forced) { | 468 TEST_F(AlternateProtocolServerPropertiesTest, Forced) { |
388 // Test forced alternate protocols. | 469 // Test forced alternate protocols. |
389 | 470 |
390 AlternateProtocolInfo default_protocol(1234, NPN_SPDY_3, 1); | 471 AlternateProtocolInfo default_protocol(1234, NPN_SPDY_3, 1); |
391 HttpServerPropertiesImpl::ForceAlternateProtocol(default_protocol); | 472 HttpServerPropertiesImpl::ForceAlternateProtocol(default_protocol); |
392 | 473 |
393 // Verify the forced protocol. | 474 // Verify the forced protocol. |
394 HostPortPair test_host_port_pair("foo", 80); | 475 HostPortPair test_host_port_pair("foo", 80); |
395 EXPECT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 476 EXPECT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
396 AlternateProtocolInfo alternate = | 477 AlternateProtocols alternate_protocols = |
397 impl_.GetAlternateProtocol(test_host_port_pair); | 478 impl_.GetAlternateProtocols(test_host_port_pair); |
398 EXPECT_EQ(default_protocol.port, alternate.port); | 479 ASSERT_EQ(1u, alternate_protocols.size()); |
399 EXPECT_EQ(default_protocol.protocol, alternate.protocol); | 480 EXPECT_EQ(default_protocol.port, alternate_protocols[0].port); |
| 481 EXPECT_EQ(default_protocol.protocol, alternate_protocols[0].protocol); |
400 | 482 |
401 // Verify the real protocol overrides the forced protocol. | 483 // Verify the real protocol overrides the forced protocol. |
402 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); | 484 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); |
403 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 485 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
404 alternate = impl_.GetAlternateProtocol(test_host_port_pair); | 486 alternate_protocols = impl_.GetAlternateProtocols(test_host_port_pair); |
405 EXPECT_EQ(443, alternate.port); | 487 ASSERT_EQ(1u, alternate_protocols.size()); |
406 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 488 EXPECT_EQ(443, alternate_protocols[0].port); |
| 489 EXPECT_EQ(NPN_SPDY_3, alternate_protocols[0].protocol); |
407 | 490 |
408 // Turn off the static, forced alternate protocol so that tests don't | 491 // Turn off the static, forced alternate protocol so that tests don't |
409 // have this state. | 492 // have this state. |
410 HttpServerPropertiesImpl::DisableForcedAlternateProtocol(); | 493 HttpServerPropertiesImpl::DisableForcedAlternateProtocol(); |
411 | 494 |
412 // Verify the forced protocol is off. | 495 // Verify the forced protocol is off. |
413 HostPortPair test_host_port_pair2("bar", 80); | 496 HostPortPair test_host_port_pair2("bar", 80); |
414 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair2)); | 497 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair2)); |
415 } | 498 } |
416 | 499 |
417 TEST_F(AlternateProtocolServerPropertiesTest, Canonical) { | 500 TEST_F(AlternateProtocolServerPropertiesTest, Canonical) { |
418 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 501 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
419 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 502 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
420 | 503 |
421 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 504 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
422 EXPECT_FALSE(impl_.HasAlternateProtocol(canonical_port_pair)); | 505 EXPECT_FALSE(impl_.HasAlternateProtocol(canonical_port_pair)); |
423 | 506 |
424 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 507 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
425 | 508 |
426 impl_.SetAlternateProtocol(canonical_port_pair, | 509 impl_.AddAlternateProtocol(canonical_port_pair, canonical_protocol.port, |
427 canonical_protocol.port, | 510 canonical_protocol.protocol, 1); |
428 canonical_protocol.protocol, | |
429 1); | |
430 // Verify the forced protocol. | 511 // Verify the forced protocol. |
431 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 512 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
432 AlternateProtocolInfo alternate = | 513 AlternateProtocols alternate_protocols = |
433 impl_.GetAlternateProtocol(test_host_port_pair); | 514 impl_.GetAlternateProtocols(test_host_port_pair); |
434 EXPECT_EQ(canonical_protocol.port, alternate.port); | 515 ASSERT_EQ(1u, alternate_protocols.size()); |
435 EXPECT_EQ(canonical_protocol.protocol, alternate.protocol); | 516 EXPECT_EQ(canonical_protocol.port, alternate_protocols[0].port); |
| 517 EXPECT_EQ(canonical_protocol.protocol, alternate_protocols[0].protocol); |
436 | 518 |
437 // Verify the canonical suffix. | 519 // Verify the canonical suffix. |
438 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(test_host_port_pair)); | 520 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(test_host_port_pair)); |
439 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(canonical_port_pair)); | 521 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(canonical_port_pair)); |
440 } | 522 } |
441 | 523 |
442 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBelowThreshold) { | 524 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBelowThreshold) { |
443 impl_.SetAlternateProtocolProbabilityThreshold(0.02); | 525 impl_.SetAlternateProtocolProbabilityThreshold(0.02); |
444 | 526 |
445 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 527 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
446 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 528 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
447 AlternateProtocolInfo canonical_protocol(1234, QUIC, 0.01); | 529 AlternateProtocolInfo canonical_protocol(1234, QUIC, 0.01); |
448 | 530 |
449 impl_.SetAlternateProtocol(canonical_port_pair, | 531 impl_.AddAlternateProtocol(canonical_port_pair, canonical_protocol.port, |
450 canonical_protocol.port, | |
451 canonical_protocol.protocol, | 532 canonical_protocol.protocol, |
452 canonical_protocol.probability); | 533 canonical_protocol.probability); |
453 EXPECT_FALSE(impl_.HasAlternateProtocol(canonical_port_pair)); | 534 EXPECT_FALSE(impl_.HasAlternateProtocol(canonical_port_pair)); |
454 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 535 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
455 } | 536 } |
456 | 537 |
457 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalAboveThreshold) { | 538 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalAboveThreshold) { |
458 impl_.SetAlternateProtocolProbabilityThreshold(0.02); | 539 impl_.SetAlternateProtocolProbabilityThreshold(0.02); |
459 | 540 |
460 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 541 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
461 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 542 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
462 AlternateProtocolInfo canonical_protocol(1234, QUIC, 0.03); | 543 AlternateProtocolInfo canonical_protocol(1234, QUIC, 0.03); |
463 | 544 |
464 impl_.SetAlternateProtocol(canonical_port_pair, | 545 impl_.AddAlternateProtocol(canonical_port_pair, canonical_protocol.port, |
465 canonical_protocol.port, | |
466 canonical_protocol.protocol, | 546 canonical_protocol.protocol, |
467 canonical_protocol.probability); | 547 canonical_protocol.probability); |
468 EXPECT_TRUE(impl_.HasAlternateProtocol(canonical_port_pair)); | 548 EXPECT_TRUE(impl_.HasAlternateProtocol(canonical_port_pair)); |
469 EXPECT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 549 EXPECT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
470 } | 550 } |
471 | 551 |
472 TEST_F(AlternateProtocolServerPropertiesTest, ClearCanonical) { | 552 TEST_F(AlternateProtocolServerPropertiesTest, ClearCanonical) { |
473 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 553 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
474 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 554 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
475 | 555 |
476 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 556 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
477 | 557 |
478 impl_.SetAlternateProtocol(canonical_port_pair, | 558 impl_.AddAlternateProtocol(canonical_port_pair, canonical_protocol.port, |
479 canonical_protocol.port, | |
480 canonical_protocol.protocol, | 559 canonical_protocol.protocol, |
481 canonical_protocol.probability); | 560 canonical_protocol.probability); |
482 | 561 |
483 impl_.ClearAlternateProtocol(canonical_port_pair); | 562 impl_.ClearAlternateProtocol(canonical_port_pair); |
484 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 563 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
485 } | 564 } |
486 | 565 |
487 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBroken) { | 566 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBroken) { |
488 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 567 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
489 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 568 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
490 | 569 |
491 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 570 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
492 | 571 |
493 impl_.SetAlternateProtocol(canonical_port_pair, | 572 impl_.AddAlternateProtocol(canonical_port_pair, canonical_protocol.port, |
494 canonical_protocol.port, | |
495 canonical_protocol.protocol, | 573 canonical_protocol.protocol, |
496 canonical_protocol.probability); | 574 canonical_protocol.probability); |
497 | 575 |
498 impl_.SetBrokenAlternateProtocol(canonical_port_pair); | 576 impl_.SetBrokenAlternateProtocol(canonical_port_pair, canonical_protocol); |
499 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 577 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
500 } | 578 } |
501 | 579 |
502 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBroken2) { | 580 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBroken2) { |
503 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 581 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
504 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 582 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
505 | 583 |
506 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 584 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
507 | 585 |
508 impl_.SetAlternateProtocol(canonical_port_pair, | 586 impl_.AddAlternateProtocol(canonical_port_pair, canonical_protocol.port, |
509 canonical_protocol.port, | |
510 canonical_protocol.protocol, | 587 canonical_protocol.protocol, |
511 canonical_protocol.probability); | 588 canonical_protocol.probability); |
512 | 589 |
513 impl_.SetBrokenAlternateProtocol(test_host_port_pair); | 590 impl_.SetBrokenAlternateProtocol(test_host_port_pair, canonical_protocol); |
514 AlternateProtocolInfo alternate = | 591 AlternateProtocols alternates = |
515 impl_.GetAlternateProtocol(test_host_port_pair); | 592 impl_.GetAlternateProtocols(test_host_port_pair); |
516 EXPECT_TRUE(alternate.is_broken); | 593 ASSERT_EQ(1u, alternates.size()); |
| 594 EXPECT_TRUE(alternates[0].is_broken); |
517 } | 595 } |
518 | 596 |
519 TEST_F(AlternateProtocolServerPropertiesTest, ClearWithCanonical) { | 597 TEST_F(AlternateProtocolServerPropertiesTest, ClearWithCanonical) { |
520 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 598 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
521 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 599 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
522 | 600 |
523 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 601 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
524 | 602 |
525 impl_.SetAlternateProtocol(canonical_port_pair, | 603 impl_.AddAlternateProtocol(canonical_port_pair, canonical_protocol.port, |
526 canonical_protocol.port, | |
527 canonical_protocol.protocol, | 604 canonical_protocol.protocol, |
528 canonical_protocol.probability); | 605 canonical_protocol.probability); |
529 | 606 |
530 impl_.Clear(); | 607 impl_.Clear(); |
531 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 608 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
532 } | 609 } |
533 | 610 |
534 typedef HttpServerPropertiesImplTest SpdySettingsServerPropertiesTest; | 611 typedef HttpServerPropertiesImplTest SpdySettingsServerPropertiesTest; |
535 | 612 |
536 TEST_F(SpdySettingsServerPropertiesTest, Initialize) { | 613 TEST_F(SpdySettingsServerPropertiesTest, Initialize) { |
(...skipping 258 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
795 EXPECT_EQ(100, stats2->bandwidth_estimate.ToBitsPerSecond()); | 872 EXPECT_EQ(100, stats2->bandwidth_estimate.ToBitsPerSecond()); |
796 | 873 |
797 impl_.Clear(); | 874 impl_.Clear(); |
798 const ServerNetworkStats* stats3 = impl_.GetServerNetworkStats(foo_server); | 875 const ServerNetworkStats* stats3 = impl_.GetServerNetworkStats(foo_server); |
799 EXPECT_EQ(NULL, stats3); | 876 EXPECT_EQ(NULL, stats3); |
800 } | 877 } |
801 | 878 |
802 } // namespace | 879 } // namespace |
803 | 880 |
804 } // namespace net | 881 } // namespace net |
OLD | NEW |