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_stream_factory_impl.h" | 5 #include "net/http/http_stream_factory_impl.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <string> | 10 #include <string> |
(...skipping 675 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
686 // list. | 686 // list. |
687 HttpRequestInfo request_info; | 687 HttpRequestInfo request_info; |
688 request_info.method = "GET"; | 688 request_info.method = "GET"; |
689 request_info.url = GURL("http://www.google.com"); | 689 request_info.url = GURL("http://www.google.com"); |
690 | 690 |
691 SSLConfig ssl_config; | 691 SSLConfig ssl_config; |
692 StreamRequestWaiter waiter; | 692 StreamRequestWaiter waiter; |
693 std::unique_ptr<HttpStreamRequest> request( | 693 std::unique_ptr<HttpStreamRequest> request( |
694 session->http_stream_factory()->RequestStream( | 694 session->http_stream_factory()->RequestStream( |
695 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 695 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
696 NetLogWithSource())); | 696 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
697 waiter.WaitForStream(); | 697 waiter.WaitForStream(); |
698 | 698 |
699 // The proxy that failed should now be known to the proxy_service as bad. | 699 // The proxy that failed should now be known to the proxy_service as bad. |
700 const ProxyRetryInfoMap& retry_info = | 700 const ProxyRetryInfoMap& retry_info = |
701 session->proxy_service()->proxy_retry_info(); | 701 session->proxy_service()->proxy_retry_info(); |
702 EXPECT_EQ(1u, retry_info.size()); | 702 EXPECT_EQ(1u, retry_info.size()); |
703 ProxyRetryInfoMap::const_iterator iter = retry_info.find("bad:99"); | 703 ProxyRetryInfoMap::const_iterator iter = retry_info.find("bad:99"); |
704 EXPECT_TRUE(iter != retry_info.end()); | 704 EXPECT_TRUE(iter != retry_info.end()); |
705 } | 705 } |
706 | 706 |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
770 // list. | 770 // list. |
771 HttpRequestInfo request_info; | 771 HttpRequestInfo request_info; |
772 request_info.method = "GET"; | 772 request_info.method = "GET"; |
773 request_info.url = GURL("http://www.google.com"); | 773 request_info.url = GURL("http://www.google.com"); |
774 | 774 |
775 SSLConfig ssl_config; | 775 SSLConfig ssl_config; |
776 StreamRequestWaiter waiter; | 776 StreamRequestWaiter waiter; |
777 std::unique_ptr<HttpStreamRequest> request( | 777 std::unique_ptr<HttpStreamRequest> request( |
778 session->http_stream_factory()->RequestStream( | 778 session->http_stream_factory()->RequestStream( |
779 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 779 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
780 NetLogWithSource())); | 780 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
781 waiter.WaitForStream(); | 781 waiter.WaitForStream(); |
782 | 782 |
783 // The proxy that failed should now be known to the proxy_service as bad. | 783 // The proxy that failed should now be known to the proxy_service as bad. |
784 const ProxyRetryInfoMap& retry_info = | 784 const ProxyRetryInfoMap& retry_info = |
785 session->proxy_service()->proxy_retry_info(); | 785 session->proxy_service()->proxy_retry_info(); |
786 EXPECT_EQ(1u, retry_info.size()) << quic_proxy_test_mock_errors[i]; | 786 EXPECT_EQ(1u, retry_info.size()) << quic_proxy_test_mock_errors[i]; |
787 EXPECT_TRUE(waiter.used_proxy_info().is_direct()); | 787 EXPECT_TRUE(waiter.used_proxy_info().is_direct()); |
788 | 788 |
789 ProxyRetryInfoMap::const_iterator iter = retry_info.find("quic://bad:99"); | 789 ProxyRetryInfoMap::const_iterator iter = retry_info.find("quic://bad:99"); |
790 EXPECT_TRUE(iter != retry_info.end()) << quic_proxy_test_mock_errors[i]; | 790 EXPECT_TRUE(iter != retry_info.end()) << quic_proxy_test_mock_errors[i]; |
(...skipping 182 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
973 | 973 |
974 // Start two requests. The first request should consume data from | 974 // Start two requests. The first request should consume data from |
975 // |socket_data_proxy_main_job|, | 975 // |socket_data_proxy_main_job|, |
976 // |socket_data_proxy_alternate_job| and | 976 // |socket_data_proxy_alternate_job| and |
977 // |socket_data_direct_first_request|. The second request should consume | 977 // |socket_data_direct_first_request|. The second request should consume |
978 // data from |socket_data_direct_second_request|. | 978 // data from |socket_data_direct_second_request|. |
979 for (size_t i = 0; i < 2; ++i) { | 979 for (size_t i = 0; i < 2; ++i) { |
980 std::unique_ptr<HttpStreamRequest> request( | 980 std::unique_ptr<HttpStreamRequest> request( |
981 session->http_stream_factory()->RequestStream( | 981 session->http_stream_factory()->RequestStream( |
982 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 982 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
983 NetLogWithSource())); | 983 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
984 waiter.WaitForStream(); | 984 waiter.WaitForStream(); |
985 | 985 |
986 // The proxy that failed should now be known to the proxy_service as | 986 // The proxy that failed should now be known to the proxy_service as |
987 // bad. | 987 // bad. |
988 const ProxyRetryInfoMap retry_info = | 988 const ProxyRetryInfoMap retry_info = |
989 session->proxy_service()->proxy_retry_info(); | 989 session->proxy_service()->proxy_retry_info(); |
990 EXPECT_EQ(2u, retry_info.size()) << mock_error; | 990 EXPECT_EQ(2u, retry_info.size()) << mock_error; |
991 | 991 |
992 // Verify that request was fetched without proxy. | 992 // Verify that request was fetched without proxy. |
993 EXPECT_TRUE(waiter.used_proxy_info().is_direct()); | 993 EXPECT_TRUE(waiter.used_proxy_info().is_direct()); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1076 | 1076 |
1077 EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); | 1077 EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
1078 | 1078 |
1079 // Start two requests. The first request should consume data from | 1079 // Start two requests. The first request should consume data from |
1080 // |socket_data_proxy_main_job| and |socket_data_https_first|. | 1080 // |socket_data_proxy_main_job| and |socket_data_https_first|. |
1081 // The second request should consume data from |socket_data_https_second|. | 1081 // The second request should consume data from |socket_data_https_second|. |
1082 for (size_t i = 0; i < 2; ++i) { | 1082 for (size_t i = 0; i < 2; ++i) { |
1083 std::unique_ptr<HttpStreamRequest> request( | 1083 std::unique_ptr<HttpStreamRequest> request( |
1084 session->http_stream_factory()->RequestStream( | 1084 session->http_stream_factory()->RequestStream( |
1085 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1085 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1086 NetLogWithSource())); | 1086 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1087 waiter.WaitForStream(); | 1087 waiter.WaitForStream(); |
1088 | 1088 |
1089 // The proxy that failed should now be known to the proxy_service as | 1089 // The proxy that failed should now be known to the proxy_service as |
1090 // bad. | 1090 // bad. |
1091 const ProxyRetryInfoMap retry_info = | 1091 const ProxyRetryInfoMap retry_info = |
1092 session->proxy_service()->proxy_retry_info(); | 1092 session->proxy_service()->proxy_retry_info(); |
1093 // Proxy should not be marked as bad. | 1093 // Proxy should not be marked as bad. |
1094 EXPECT_EQ(0u, retry_info.size()) << mock_error; | 1094 EXPECT_EQ(0u, retry_info.size()) << mock_error; |
1095 // Verify that request was fetched using proxy. | 1095 // Verify that request was fetched using proxy. |
1096 EXPECT_TRUE(waiter.used_proxy_info().is_https()); | 1096 EXPECT_TRUE(waiter.used_proxy_info().is_https()); |
(...skipping 323 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1420 request_info.method = "GET"; | 1420 request_info.method = "GET"; |
1421 request_info.url = GURL("https://www.google.com"); | 1421 request_info.url = GURL("https://www.google.com"); |
1422 request_info.load_flags = 0; | 1422 request_info.load_flags = 0; |
1423 request_info.privacy_mode = PRIVACY_MODE_DISABLED; | 1423 request_info.privacy_mode = PRIVACY_MODE_DISABLED; |
1424 | 1424 |
1425 SSLConfig ssl_config; | 1425 SSLConfig ssl_config; |
1426 StreamRequestWaiter waiter; | 1426 StreamRequestWaiter waiter; |
1427 std::unique_ptr<HttpStreamRequest> request( | 1427 std::unique_ptr<HttpStreamRequest> request( |
1428 session->http_stream_factory()->RequestStream( | 1428 session->http_stream_factory()->RequestStream( |
1429 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1429 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1430 NetLogWithSource())); | 1430 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1431 waiter.WaitForStream(); | 1431 waiter.WaitForStream(); |
1432 | 1432 |
1433 // The stream shouldn't come from spdy as we are using different privacy mode | 1433 // The stream shouldn't come from spdy as we are using different privacy mode |
1434 EXPECT_FALSE(request->using_spdy()); | 1434 EXPECT_FALSE(request->using_spdy()); |
1435 | 1435 |
1436 SSLConfig used_ssl_config = waiter.used_ssl_config(); | 1436 SSLConfig used_ssl_config = waiter.used_ssl_config(); |
1437 EXPECT_EQ(used_ssl_config.channel_id_enabled, ssl_config.channel_id_enabled); | 1437 EXPECT_EQ(used_ssl_config.channel_id_enabled, ssl_config.channel_id_enabled); |
1438 } | 1438 } |
1439 | 1439 |
1440 namespace { | 1440 namespace { |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1496 request_info.url = GURL("https://www.google.com"); | 1496 request_info.url = GURL("https://www.google.com"); |
1497 request_info.load_flags = 0; | 1497 request_info.load_flags = 0; |
1498 request_info.privacy_mode = PRIVACY_MODE_DISABLED; | 1498 request_info.privacy_mode = PRIVACY_MODE_DISABLED; |
1499 | 1499 |
1500 SSLConfig ssl_config; | 1500 SSLConfig ssl_config; |
1501 StreamRequestWaiter waiter; | 1501 StreamRequestWaiter waiter; |
1502 | 1502 |
1503 std::unique_ptr<HttpStreamRequest> request1( | 1503 std::unique_ptr<HttpStreamRequest> request1( |
1504 session->http_stream_factory()->RequestStream( | 1504 session->http_stream_factory()->RequestStream( |
1505 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1505 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1506 NetLogWithSource())); | 1506 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1507 waiter.WaitForStream(); | 1507 waiter.WaitForStream(); |
1508 | 1508 |
1509 EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1); | 1509 EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1); |
1510 | 1510 |
1511 std::unique_ptr<HttpStreamRequest> request2( | 1511 std::unique_ptr<HttpStreamRequest> request2( |
1512 session->http_stream_factory()->RequestStream( | 1512 session->http_stream_factory()->RequestStream( |
1513 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1513 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1514 NetLogWithSource())); | 1514 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1515 waiter.WaitForStream(); | 1515 waiter.WaitForStream(); |
1516 | 1516 |
1517 EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1); | 1517 EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1); |
1518 | 1518 |
1519 request_info.privacy_mode = PRIVACY_MODE_ENABLED; | 1519 request_info.privacy_mode = PRIVACY_MODE_ENABLED; |
1520 std::unique_ptr<HttpStreamRequest> request3( | 1520 std::unique_ptr<HttpStreamRequest> request3( |
1521 session->http_stream_factory()->RequestStream( | 1521 session->http_stream_factory()->RequestStream( |
1522 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1522 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1523 NetLogWithSource())); | 1523 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1524 waiter.WaitForStream(); | 1524 waiter.WaitForStream(); |
1525 | 1525 |
1526 EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 2); | 1526 EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 2); |
1527 } | 1527 } |
1528 | 1528 |
1529 TEST_F(HttpStreamFactoryTest, GetLoadState) { | 1529 TEST_F(HttpStreamFactoryTest, GetLoadState) { |
1530 SpdySessionDependencies session_deps(ProxyService::CreateDirect()); | 1530 SpdySessionDependencies session_deps(ProxyService::CreateDirect()); |
1531 | 1531 |
1532 // Force asynchronous host resolutions, so that the LoadState will be | 1532 // Force asynchronous host resolutions, so that the LoadState will be |
1533 // resolving the host. | 1533 // resolving the host. |
1534 session_deps.host_resolver->set_synchronous_mode(false); | 1534 session_deps.host_resolver->set_synchronous_mode(false); |
1535 | 1535 |
1536 StaticSocketDataProvider socket_data; | 1536 StaticSocketDataProvider socket_data; |
1537 socket_data.set_connect_data(MockConnect(ASYNC, OK)); | 1537 socket_data.set_connect_data(MockConnect(ASYNC, OK)); |
1538 session_deps.socket_factory->AddSocketDataProvider(&socket_data); | 1538 session_deps.socket_factory->AddSocketDataProvider(&socket_data); |
1539 | 1539 |
1540 std::unique_ptr<HttpNetworkSession> session( | 1540 std::unique_ptr<HttpNetworkSession> session( |
1541 SpdySessionDependencies::SpdyCreateSession(&session_deps)); | 1541 SpdySessionDependencies::SpdyCreateSession(&session_deps)); |
1542 | 1542 |
1543 HttpRequestInfo request_info; | 1543 HttpRequestInfo request_info; |
1544 request_info.method = "GET"; | 1544 request_info.method = "GET"; |
1545 request_info.url = GURL("http://www.google.com"); | 1545 request_info.url = GURL("http://www.google.com"); |
1546 | 1546 |
1547 SSLConfig ssl_config; | 1547 SSLConfig ssl_config; |
1548 StreamRequestWaiter waiter; | 1548 StreamRequestWaiter waiter; |
1549 std::unique_ptr<HttpStreamRequest> request( | 1549 std::unique_ptr<HttpStreamRequest> request( |
1550 session->http_stream_factory()->RequestStream( | 1550 session->http_stream_factory()->RequestStream( |
1551 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1551 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1552 NetLogWithSource())); | 1552 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1553 | 1553 |
1554 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, request->GetLoadState()); | 1554 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, request->GetLoadState()); |
1555 | 1555 |
1556 waiter.WaitForStream(); | 1556 waiter.WaitForStream(); |
1557 } | 1557 } |
1558 | 1558 |
1559 TEST_F(HttpStreamFactoryTest, RequestHttpStream) { | 1559 TEST_F(HttpStreamFactoryTest, RequestHttpStream) { |
1560 SpdySessionDependencies session_deps(ProxyService::CreateDirect()); | 1560 SpdySessionDependencies session_deps(ProxyService::CreateDirect()); |
1561 | 1561 |
1562 StaticSocketDataProvider socket_data; | 1562 StaticSocketDataProvider socket_data; |
1563 socket_data.set_connect_data(MockConnect(ASYNC, OK)); | 1563 socket_data.set_connect_data(MockConnect(ASYNC, OK)); |
1564 session_deps.socket_factory->AddSocketDataProvider(&socket_data); | 1564 session_deps.socket_factory->AddSocketDataProvider(&socket_data); |
1565 | 1565 |
1566 std::unique_ptr<HttpNetworkSession> session( | 1566 std::unique_ptr<HttpNetworkSession> session( |
1567 SpdySessionDependencies::SpdyCreateSession(&session_deps)); | 1567 SpdySessionDependencies::SpdyCreateSession(&session_deps)); |
1568 | 1568 |
1569 // Now request a stream. It should succeed using the second proxy in the | 1569 // Now request a stream. It should succeed using the second proxy in the |
1570 // list. | 1570 // list. |
1571 HttpRequestInfo request_info; | 1571 HttpRequestInfo request_info; |
1572 request_info.method = "GET"; | 1572 request_info.method = "GET"; |
1573 request_info.url = GURL("http://www.google.com"); | 1573 request_info.url = GURL("http://www.google.com"); |
1574 request_info.load_flags = 0; | 1574 request_info.load_flags = 0; |
1575 | 1575 |
1576 SSLConfig ssl_config; | 1576 SSLConfig ssl_config; |
1577 StreamRequestWaiter waiter; | 1577 StreamRequestWaiter waiter; |
1578 std::unique_ptr<HttpStreamRequest> request( | 1578 std::unique_ptr<HttpStreamRequest> request( |
1579 session->http_stream_factory()->RequestStream( | 1579 session->http_stream_factory()->RequestStream( |
1580 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1580 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1581 NetLogWithSource())); | 1581 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1582 waiter.WaitForStream(); | 1582 waiter.WaitForStream(); |
1583 EXPECT_TRUE(waiter.stream_done()); | 1583 EXPECT_TRUE(waiter.stream_done()); |
1584 ASSERT_TRUE(nullptr != waiter.stream()); | 1584 ASSERT_TRUE(nullptr != waiter.stream()); |
1585 EXPECT_TRUE(nullptr == waiter.websocket_stream()); | 1585 EXPECT_TRUE(nullptr == waiter.websocket_stream()); |
1586 | 1586 |
1587 EXPECT_EQ(0, GetSpdySessionCount(session.get())); | 1587 EXPECT_EQ(0, GetSpdySessionCount(session.get())); |
1588 EXPECT_EQ(1, GetSocketPoolGroupCount( | 1588 EXPECT_EQ(1, GetSocketPoolGroupCount( |
1589 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1589 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
1590 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool( | 1590 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool( |
1591 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1591 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 28 matching lines...) Expand all Loading... |
1620 request_info.method = "GET"; | 1620 request_info.method = "GET"; |
1621 request_info.url = GURL("https://www.google.com"); | 1621 request_info.url = GURL("https://www.google.com"); |
1622 request_info.load_flags = 0; | 1622 request_info.load_flags = 0; |
1623 | 1623 |
1624 SSLConfig ssl_config; | 1624 SSLConfig ssl_config; |
1625 StreamRequestWaiter waiter; | 1625 StreamRequestWaiter waiter; |
1626 EXPECT_EQ(0, GetSpdySessionCount(session.get())); | 1626 EXPECT_EQ(0, GetSpdySessionCount(session.get())); |
1627 std::unique_ptr<HttpStreamRequest> request( | 1627 std::unique_ptr<HttpStreamRequest> request( |
1628 session->http_stream_factory()->RequestStream( | 1628 session->http_stream_factory()->RequestStream( |
1629 request_info, LOWEST, ssl_config, ssl_config, &waiter, | 1629 request_info, LOWEST, ssl_config, ssl_config, &waiter, |
1630 NetLogWithSource())); | 1630 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1631 EXPECT_FALSE(waiter.stream_done()); | 1631 EXPECT_FALSE(waiter.stream_done()); |
1632 | 1632 |
1633 // Confirm a stream has been created by asserting that a new session | 1633 // Confirm a stream has been created by asserting that a new session |
1634 // has been created. (The stream is only created at the SPDY level on | 1634 // has been created. (The stream is only created at the SPDY level on |
1635 // first write, which happens after the request has returned a stream). | 1635 // first write, which happens after the request has returned a stream). |
1636 ASSERT_EQ(1, GetSpdySessionCount(session.get())); | 1636 ASSERT_EQ(1, GetSpdySessionCount(session.get())); |
1637 | 1637 |
1638 // Test to confirm that a SetPriority received after the stream is created | 1638 // Test to confirm that a SetPriority received after the stream is created |
1639 // but before the request returns it does not crash. | 1639 // but before the request returns it does not crash. |
1640 request->SetPriority(HIGHEST); | 1640 request->SetPriority(HIGHEST); |
(...skipping 22 matching lines...) Expand all Loading... |
1663 HttpRequestInfo request_info; | 1663 HttpRequestInfo request_info; |
1664 request_info.method = "GET"; | 1664 request_info.method = "GET"; |
1665 request_info.url = GURL("https://www.google.com"); | 1665 request_info.url = GURL("https://www.google.com"); |
1666 request_info.load_flags = 0; | 1666 request_info.load_flags = 0; |
1667 | 1667 |
1668 SSLConfig ssl_config; | 1668 SSLConfig ssl_config; |
1669 StreamRequestWaiter waiter; | 1669 StreamRequestWaiter waiter; |
1670 std::unique_ptr<HttpStreamRequest> request( | 1670 std::unique_ptr<HttpStreamRequest> request( |
1671 session->http_stream_factory()->RequestStream( | 1671 session->http_stream_factory()->RequestStream( |
1672 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1672 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1673 NetLogWithSource())); | 1673 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1674 waiter.WaitForStream(); | 1674 waiter.WaitForStream(); |
1675 EXPECT_TRUE(waiter.stream_done()); | 1675 EXPECT_TRUE(waiter.stream_done()); |
1676 ASSERT_TRUE(nullptr != waiter.stream()); | 1676 ASSERT_TRUE(nullptr != waiter.stream()); |
1677 EXPECT_TRUE(nullptr == waiter.websocket_stream()); | 1677 EXPECT_TRUE(nullptr == waiter.websocket_stream()); |
1678 | 1678 |
1679 EXPECT_EQ(0, GetSpdySessionCount(session.get())); | 1679 EXPECT_EQ(0, GetSpdySessionCount(session.get())); |
1680 EXPECT_EQ(1, GetSocketPoolGroupCount( | 1680 EXPECT_EQ(1, GetSocketPoolGroupCount( |
1681 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1681 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
1682 EXPECT_EQ(1, GetSocketPoolGroupCount( | 1682 EXPECT_EQ(1, GetSocketPoolGroupCount( |
1683 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1683 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 21 matching lines...) Expand all Loading... |
1705 HttpRequestInfo request_info; | 1705 HttpRequestInfo request_info; |
1706 request_info.method = "GET"; | 1706 request_info.method = "GET"; |
1707 request_info.url = GURL("http://www.google.com"); | 1707 request_info.url = GURL("http://www.google.com"); |
1708 request_info.load_flags = 0; | 1708 request_info.load_flags = 0; |
1709 | 1709 |
1710 SSLConfig ssl_config; | 1710 SSLConfig ssl_config; |
1711 StreamRequestWaiter waiter; | 1711 StreamRequestWaiter waiter; |
1712 std::unique_ptr<HttpStreamRequest> request( | 1712 std::unique_ptr<HttpStreamRequest> request( |
1713 session->http_stream_factory()->RequestStream( | 1713 session->http_stream_factory()->RequestStream( |
1714 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1714 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1715 NetLogWithSource())); | 1715 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1716 waiter.WaitForStream(); | 1716 waiter.WaitForStream(); |
1717 EXPECT_TRUE(waiter.stream_done()); | 1717 EXPECT_TRUE(waiter.stream_done()); |
1718 ASSERT_TRUE(nullptr != waiter.stream()); | 1718 ASSERT_TRUE(nullptr != waiter.stream()); |
1719 EXPECT_TRUE(nullptr == waiter.websocket_stream()); | 1719 EXPECT_TRUE(nullptr == waiter.websocket_stream()); |
1720 | 1720 |
1721 EXPECT_EQ(0, GetSpdySessionCount(session.get())); | 1721 EXPECT_EQ(0, GetSpdySessionCount(session.get())); |
1722 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1722 EXPECT_EQ(0, GetSocketPoolGroupCount( |
1723 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1723 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
1724 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1724 EXPECT_EQ(0, GetSocketPoolGroupCount( |
1725 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1725 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1787 histogram_tester.ExpectUniqueSample("Net.PreconnectSkippedToProxyServers", 1, | 1787 histogram_tester.ExpectUniqueSample("Net.PreconnectSkippedToProxyServers", 1, |
1788 num_preconnects - 1); | 1788 num_preconnects - 1); |
1789 | 1789 |
1790 // Start a request. This should cause subsequent preconnect to proxy server to | 1790 // Start a request. This should cause subsequent preconnect to proxy server to |
1791 // succeed. | 1791 // succeed. |
1792 SSLConfig ssl_config; | 1792 SSLConfig ssl_config; |
1793 StreamRequestWaiter waiter; | 1793 StreamRequestWaiter waiter; |
1794 std::unique_ptr<HttpStreamRequest> request( | 1794 std::unique_ptr<HttpStreamRequest> request( |
1795 session->http_stream_factory()->RequestStream( | 1795 session->http_stream_factory()->RequestStream( |
1796 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1796 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1797 NetLogWithSource())); | 1797 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1798 waiter.WaitForStream(); | 1798 waiter.WaitForStream(); |
1799 EXPECT_TRUE(waiter.stream_done()); | 1799 EXPECT_TRUE(waiter.stream_done()); |
1800 ASSERT_TRUE(nullptr != waiter.stream()); | 1800 ASSERT_TRUE(nullptr != waiter.stream()); |
1801 EXPECT_TRUE(nullptr == waiter.websocket_stream()); | 1801 EXPECT_TRUE(nullptr == waiter.websocket_stream()); |
1802 | 1802 |
1803 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy( | 1803 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy( |
1804 HttpNetworkSession::NORMAL_SOCKET_POOL, | 1804 HttpNetworkSession::NORMAL_SOCKET_POOL, |
1805 HostPortPair("myproxy.org", 443)))); | 1805 HostPortPair("myproxy.org", 443)))); |
1806 EXPECT_FALSE(waiter.used_proxy_info().is_direct()); | 1806 EXPECT_FALSE(waiter.used_proxy_info().is_direct()); |
1807 | 1807 |
(...skipping 28 matching lines...) Expand all Loading... |
1836 request_info.url = GURL("ws://www.google.com"); | 1836 request_info.url = GURL("ws://www.google.com"); |
1837 request_info.load_flags = 0; | 1837 request_info.load_flags = 0; |
1838 | 1838 |
1839 SSLConfig ssl_config; | 1839 SSLConfig ssl_config; |
1840 StreamRequestWaiter waiter; | 1840 StreamRequestWaiter waiter; |
1841 WebSocketStreamCreateHelper create_helper; | 1841 WebSocketStreamCreateHelper create_helper; |
1842 std::unique_ptr<HttpStreamRequest> request( | 1842 std::unique_ptr<HttpStreamRequest> request( |
1843 session->http_stream_factory_for_websocket() | 1843 session->http_stream_factory_for_websocket() |
1844 ->RequestWebSocketHandshakeStream( | 1844 ->RequestWebSocketHandshakeStream( |
1845 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1845 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1846 &create_helper, NetLogWithSource())); | 1846 &create_helper, |
| 1847 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1847 waiter.WaitForStream(); | 1848 waiter.WaitForStream(); |
1848 EXPECT_TRUE(waiter.stream_done()); | 1849 EXPECT_TRUE(waiter.stream_done()); |
1849 EXPECT_TRUE(nullptr == waiter.stream()); | 1850 EXPECT_TRUE(nullptr == waiter.stream()); |
1850 ASSERT_TRUE(nullptr != waiter.websocket_stream()); | 1851 ASSERT_TRUE(nullptr != waiter.websocket_stream()); |
1851 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, | 1852 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, |
1852 waiter.websocket_stream()->type()); | 1853 waiter.websocket_stream()->type()); |
1853 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1854 EXPECT_EQ(0, GetSocketPoolGroupCount( |
1854 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1855 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
1855 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1856 EXPECT_EQ(0, GetSocketPoolGroupCount( |
1856 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1857 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 22 matching lines...) Expand all Loading... |
1879 request_info.url = GURL("wss://www.google.com"); | 1880 request_info.url = GURL("wss://www.google.com"); |
1880 request_info.load_flags = 0; | 1881 request_info.load_flags = 0; |
1881 | 1882 |
1882 SSLConfig ssl_config; | 1883 SSLConfig ssl_config; |
1883 StreamRequestWaiter waiter; | 1884 StreamRequestWaiter waiter; |
1884 WebSocketStreamCreateHelper create_helper; | 1885 WebSocketStreamCreateHelper create_helper; |
1885 std::unique_ptr<HttpStreamRequest> request( | 1886 std::unique_ptr<HttpStreamRequest> request( |
1886 session->http_stream_factory_for_websocket() | 1887 session->http_stream_factory_for_websocket() |
1887 ->RequestWebSocketHandshakeStream( | 1888 ->RequestWebSocketHandshakeStream( |
1888 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1889 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1889 &create_helper, NetLogWithSource())); | 1890 &create_helper, |
| 1891 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1890 waiter.WaitForStream(); | 1892 waiter.WaitForStream(); |
1891 EXPECT_TRUE(waiter.stream_done()); | 1893 EXPECT_TRUE(waiter.stream_done()); |
1892 EXPECT_TRUE(nullptr == waiter.stream()); | 1894 EXPECT_TRUE(nullptr == waiter.stream()); |
1893 ASSERT_TRUE(nullptr != waiter.websocket_stream()); | 1895 ASSERT_TRUE(nullptr != waiter.websocket_stream()); |
1894 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, | 1896 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, |
1895 waiter.websocket_stream()->type()); | 1897 waiter.websocket_stream()->type()); |
1896 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1898 EXPECT_EQ(0, GetSocketPoolGroupCount( |
1897 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1899 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
1898 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1900 EXPECT_EQ(0, GetSocketPoolGroupCount( |
1899 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1901 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 20 matching lines...) Expand all Loading... |
1920 request_info.url = GURL("ws://www.google.com"); | 1922 request_info.url = GURL("ws://www.google.com"); |
1921 request_info.load_flags = 0; | 1923 request_info.load_flags = 0; |
1922 | 1924 |
1923 SSLConfig ssl_config; | 1925 SSLConfig ssl_config; |
1924 StreamRequestWaiter waiter; | 1926 StreamRequestWaiter waiter; |
1925 WebSocketStreamCreateHelper create_helper; | 1927 WebSocketStreamCreateHelper create_helper; |
1926 std::unique_ptr<HttpStreamRequest> request( | 1928 std::unique_ptr<HttpStreamRequest> request( |
1927 session->http_stream_factory_for_websocket() | 1929 session->http_stream_factory_for_websocket() |
1928 ->RequestWebSocketHandshakeStream( | 1930 ->RequestWebSocketHandshakeStream( |
1929 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1931 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1930 &create_helper, NetLogWithSource())); | 1932 &create_helper, |
| 1933 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1931 waiter.WaitForStream(); | 1934 waiter.WaitForStream(); |
1932 EXPECT_TRUE(waiter.stream_done()); | 1935 EXPECT_TRUE(waiter.stream_done()); |
1933 EXPECT_TRUE(nullptr == waiter.stream()); | 1936 EXPECT_TRUE(nullptr == waiter.stream()); |
1934 ASSERT_TRUE(nullptr != waiter.websocket_stream()); | 1937 ASSERT_TRUE(nullptr != waiter.websocket_stream()); |
1935 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, | 1938 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, |
1936 waiter.websocket_stream()->type()); | 1939 waiter.websocket_stream()->type()); |
1937 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1940 EXPECT_EQ(0, GetSocketPoolGroupCount( |
1938 session->GetTransportSocketPool( | 1941 session->GetTransportSocketPool( |
1939 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); | 1942 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); |
1940 EXPECT_EQ(0, GetSocketPoolGroupCount( | 1943 EXPECT_EQ(0, GetSocketPoolGroupCount( |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1974 HttpRequestInfo request_info; | 1977 HttpRequestInfo request_info; |
1975 request_info.method = "GET"; | 1978 request_info.method = "GET"; |
1976 request_info.url = GURL("https://www.google.com"); | 1979 request_info.url = GURL("https://www.google.com"); |
1977 request_info.load_flags = 0; | 1980 request_info.load_flags = 0; |
1978 | 1981 |
1979 SSLConfig ssl_config; | 1982 SSLConfig ssl_config; |
1980 StreamRequestWaiter waiter; | 1983 StreamRequestWaiter waiter; |
1981 std::unique_ptr<HttpStreamRequest> request( | 1984 std::unique_ptr<HttpStreamRequest> request( |
1982 session->http_stream_factory()->RequestStream( | 1985 session->http_stream_factory()->RequestStream( |
1983 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 1986 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
1984 NetLogWithSource())); | 1987 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
1985 waiter.WaitForStream(); | 1988 waiter.WaitForStream(); |
1986 EXPECT_TRUE(waiter.stream_done()); | 1989 EXPECT_TRUE(waiter.stream_done()); |
1987 EXPECT_TRUE(nullptr == waiter.websocket_stream()); | 1990 EXPECT_TRUE(nullptr == waiter.websocket_stream()); |
1988 ASSERT_TRUE(nullptr != waiter.stream()); | 1991 ASSERT_TRUE(nullptr != waiter.stream()); |
1989 | 1992 |
1990 EXPECT_EQ(1, GetSpdySessionCount(session.get())); | 1993 EXPECT_EQ(1, GetSpdySessionCount(session.get())); |
1991 EXPECT_EQ(1, GetSocketPoolGroupCount( | 1994 EXPECT_EQ(1, GetSocketPoolGroupCount( |
1992 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1995 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
1993 EXPECT_EQ(1, GetSocketPoolGroupCount( | 1996 EXPECT_EQ(1, GetSocketPoolGroupCount( |
1994 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 1997 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2028 HttpRequestInfo request_info; | 2031 HttpRequestInfo request_info; |
2029 request_info.method = "GET"; | 2032 request_info.method = "GET"; |
2030 request_info.url = GURL("http://www.google.com"); | 2033 request_info.url = GURL("http://www.google.com"); |
2031 request_info.load_flags = 0; | 2034 request_info.load_flags = 0; |
2032 | 2035 |
2033 SSLConfig ssl_config; | 2036 SSLConfig ssl_config; |
2034 StreamRequestWaiter waiter; | 2037 StreamRequestWaiter waiter; |
2035 std::unique_ptr<HttpStreamRequest> request( | 2038 std::unique_ptr<HttpStreamRequest> request( |
2036 session->http_stream_factory()->RequestStream( | 2039 session->http_stream_factory()->RequestStream( |
2037 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 2040 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
2038 NetLogWithSource())); | 2041 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2039 waiter.WaitForStream(); | 2042 waiter.WaitForStream(); |
2040 EXPECT_TRUE(waiter.stream_done()); | 2043 EXPECT_TRUE(waiter.stream_done()); |
2041 EXPECT_TRUE(nullptr == waiter.websocket_stream()); | 2044 EXPECT_TRUE(nullptr == waiter.websocket_stream()); |
2042 ASSERT_TRUE(nullptr != waiter.stream()); | 2045 ASSERT_TRUE(nullptr != waiter.stream()); |
2043 | 2046 |
2044 EXPECT_EQ(1, GetSpdySessionCount(session.get())); | 2047 EXPECT_EQ(1, GetSpdySessionCount(session.get())); |
2045 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool( | 2048 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool( |
2046 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2049 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2047 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool( | 2050 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool( |
2048 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2051 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2114 request_info.method = "GET"; | 2117 request_info.method = "GET"; |
2115 request_info.url = GURL("https://www.google.com"); | 2118 request_info.url = GURL("https://www.google.com"); |
2116 request_info.load_flags = 0; | 2119 request_info.load_flags = 0; |
2117 | 2120 |
2118 SSLConfig ssl_config; | 2121 SSLConfig ssl_config; |
2119 StreamRequestWaiter waiter1; | 2122 StreamRequestWaiter waiter1; |
2120 StreamRequestWaiter waiter2; | 2123 StreamRequestWaiter waiter2; |
2121 std::unique_ptr<HttpStreamRequest> request1( | 2124 std::unique_ptr<HttpStreamRequest> request1( |
2122 session->http_stream_factory()->RequestStream( | 2125 session->http_stream_factory()->RequestStream( |
2123 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1, | 2126 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1, |
2124 NetLogWithSource())); | 2127 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2125 std::unique_ptr<HttpStreamRequest> request2( | 2128 std::unique_ptr<HttpStreamRequest> request2( |
2126 session->http_stream_factory()->RequestStream( | 2129 session->http_stream_factory()->RequestStream( |
2127 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2, | 2130 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2, |
2128 NetLogWithSource())); | 2131 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2129 waiter1.WaitForStream(); | 2132 waiter1.WaitForStream(); |
2130 waiter2.WaitForStream(); | 2133 waiter2.WaitForStream(); |
2131 EXPECT_TRUE(waiter1.stream_done()); | 2134 EXPECT_TRUE(waiter1.stream_done()); |
2132 EXPECT_TRUE(waiter2.stream_done()); | 2135 EXPECT_TRUE(waiter2.stream_done()); |
2133 ASSERT_NE(nullptr, waiter1.stream()); | 2136 ASSERT_NE(nullptr, waiter1.stream()); |
2134 ASSERT_NE(nullptr, waiter2.stream()); | 2137 ASSERT_NE(nullptr, waiter2.stream()); |
2135 ASSERT_NE(waiter1.stream(), waiter2.stream()); | 2138 ASSERT_NE(waiter1.stream(), waiter2.stream()); |
2136 | 2139 |
2137 // Establishing the SpdySession will close idle H2 sockets. | 2140 // Establishing the SpdySession will close idle H2 sockets. |
2138 EXPECT_EQ(0, session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL) | 2141 EXPECT_EQ(0, session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL) |
(...skipping 21 matching lines...) Expand all Loading... |
2160 HttpRequestInfo request_info; | 2163 HttpRequestInfo request_info; |
2161 request_info.method = "GET"; | 2164 request_info.method = "GET"; |
2162 request_info.url = GURL("https://www.google.com"); | 2165 request_info.url = GURL("https://www.google.com"); |
2163 request_info.load_flags = 0; | 2166 request_info.load_flags = 0; |
2164 | 2167 |
2165 SSLConfig ssl_config; | 2168 SSLConfig ssl_config; |
2166 StreamRequestWaiter waiter; | 2169 StreamRequestWaiter waiter; |
2167 std::unique_ptr<HttpStreamRequest> request( | 2170 std::unique_ptr<HttpStreamRequest> request( |
2168 session->http_stream_factory()->RequestBidirectionalStreamImpl( | 2171 session->http_stream_factory()->RequestBidirectionalStreamImpl( |
2169 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 2172 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
2170 NetLogWithSource())); | 2173 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2171 waiter.WaitForStream(); | 2174 waiter.WaitForStream(); |
2172 EXPECT_TRUE(waiter.stream_done()); | 2175 EXPECT_TRUE(waiter.stream_done()); |
2173 EXPECT_FALSE(waiter.websocket_stream()); | 2176 EXPECT_FALSE(waiter.websocket_stream()); |
2174 ASSERT_FALSE(waiter.stream()); | 2177 ASSERT_FALSE(waiter.stream()); |
2175 ASSERT_TRUE(waiter.bidirectional_stream_impl()); | 2178 ASSERT_TRUE(waiter.bidirectional_stream_impl()); |
2176 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetTransportSocketPool( | 2179 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetTransportSocketPool( |
2177 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2180 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2178 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSSLSocketPool( | 2181 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSSLSocketPool( |
2179 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2182 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2180 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool( | 2183 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool( |
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2333 SSLConfig ssl_config; | 2336 SSLConfig ssl_config; |
2334 HttpRequestInfo request_info; | 2337 HttpRequestInfo request_info; |
2335 request_info.method = "GET"; | 2338 request_info.method = "GET"; |
2336 request_info.url = default_url_; | 2339 request_info.url = default_url_; |
2337 request_info.load_flags = 0; | 2340 request_info.load_flags = 0; |
2338 | 2341 |
2339 StreamRequestWaiter waiter; | 2342 StreamRequestWaiter waiter; |
2340 std::unique_ptr<HttpStreamRequest> request( | 2343 std::unique_ptr<HttpStreamRequest> request( |
2341 session()->http_stream_factory()->RequestBidirectionalStreamImpl( | 2344 session()->http_stream_factory()->RequestBidirectionalStreamImpl( |
2342 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 2345 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
2343 NetLogWithSource())); | 2346 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2344 | 2347 |
2345 waiter.WaitForStream(); | 2348 waiter.WaitForStream(); |
2346 EXPECT_TRUE(waiter.stream_done()); | 2349 EXPECT_TRUE(waiter.stream_done()); |
2347 EXPECT_FALSE(waiter.websocket_stream()); | 2350 EXPECT_FALSE(waiter.websocket_stream()); |
2348 ASSERT_FALSE(waiter.stream()); | 2351 ASSERT_FALSE(waiter.stream()); |
2349 ASSERT_TRUE(waiter.bidirectional_stream_impl()); | 2352 ASSERT_TRUE(waiter.bidirectional_stream_impl()); |
2350 BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl(); | 2353 BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl(); |
2351 | 2354 |
2352 BidirectionalStreamRequestInfo bidi_request_info; | 2355 BidirectionalStreamRequestInfo bidi_request_info; |
2353 bidi_request_info.method = "GET"; | 2356 bidi_request_info.method = "GET"; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2398 SSLConfig ssl_config; | 2401 SSLConfig ssl_config; |
2399 HttpRequestInfo request_info; | 2402 HttpRequestInfo request_info; |
2400 request_info.method = "GET"; | 2403 request_info.method = "GET"; |
2401 request_info.url = default_url_; | 2404 request_info.url = default_url_; |
2402 request_info.load_flags = 0; | 2405 request_info.load_flags = 0; |
2403 | 2406 |
2404 StreamRequestWaiter waiter; | 2407 StreamRequestWaiter waiter; |
2405 std::unique_ptr<HttpStreamRequest> request( | 2408 std::unique_ptr<HttpStreamRequest> request( |
2406 session()->http_stream_factory()->RequestBidirectionalStreamImpl( | 2409 session()->http_stream_factory()->RequestBidirectionalStreamImpl( |
2407 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 2410 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
2408 NetLogWithSource())); | 2411 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2409 | 2412 |
2410 waiter.WaitForStream(); | 2413 waiter.WaitForStream(); |
2411 EXPECT_TRUE(waiter.stream_done()); | 2414 EXPECT_TRUE(waiter.stream_done()); |
2412 EXPECT_FALSE(waiter.websocket_stream()); | 2415 EXPECT_FALSE(waiter.websocket_stream()); |
2413 ASSERT_FALSE(waiter.stream()); | 2416 ASSERT_FALSE(waiter.stream()); |
2414 ASSERT_FALSE(waiter.bidirectional_stream_impl()); | 2417 ASSERT_FALSE(waiter.bidirectional_stream_impl()); |
2415 // Since the alternative service job is not started, we will get the error | 2418 // Since the alternative service job is not started, we will get the error |
2416 // from the http job. | 2419 // from the http job. |
2417 ASSERT_THAT(waiter.error_status(), IsError(ERR_CONNECTION_REFUSED)); | 2420 ASSERT_THAT(waiter.error_status(), IsError(ERR_CONNECTION_REFUSED)); |
2418 } | 2421 } |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2460 SSLConfig ssl_config; | 2463 SSLConfig ssl_config; |
2461 HttpRequestInfo request_info; | 2464 HttpRequestInfo request_info; |
2462 request_info.method = "GET"; | 2465 request_info.method = "GET"; |
2463 request_info.url = default_url_; | 2466 request_info.url = default_url_; |
2464 request_info.load_flags = 0; | 2467 request_info.load_flags = 0; |
2465 | 2468 |
2466 StreamRequestWaiter waiter; | 2469 StreamRequestWaiter waiter; |
2467 std::unique_ptr<HttpStreamRequest> request( | 2470 std::unique_ptr<HttpStreamRequest> request( |
2468 session()->http_stream_factory()->RequestBidirectionalStreamImpl( | 2471 session()->http_stream_factory()->RequestBidirectionalStreamImpl( |
2469 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 2472 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
2470 NetLogWithSource())); | 2473 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2471 | 2474 |
2472 waiter.WaitForStream(); | 2475 waiter.WaitForStream(); |
2473 EXPECT_TRUE(waiter.stream_done()); | 2476 EXPECT_TRUE(waiter.stream_done()); |
2474 EXPECT_FALSE(waiter.websocket_stream()); | 2477 EXPECT_FALSE(waiter.websocket_stream()); |
2475 ASSERT_FALSE(waiter.stream()); | 2478 ASSERT_FALSE(waiter.stream()); |
2476 ASSERT_TRUE(waiter.bidirectional_stream_impl()); | 2479 ASSERT_TRUE(waiter.bidirectional_stream_impl()); |
2477 BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl(); | 2480 BidirectionalStreamImpl* stream_impl = waiter.bidirectional_stream_impl(); |
2478 | 2481 |
2479 BidirectionalStreamRequestInfo bidi_request_info; | 2482 BidirectionalStreamRequestInfo bidi_request_info; |
2480 bidi_request_info.method = "GET"; | 2483 bidi_request_info.method = "GET"; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2527 HttpRequestInfo request_info; | 2530 HttpRequestInfo request_info; |
2528 request_info.method = "GET"; | 2531 request_info.method = "GET"; |
2529 request_info.url = GURL("https://www.google.com"); | 2532 request_info.url = GURL("https://www.google.com"); |
2530 request_info.load_flags = 0; | 2533 request_info.load_flags = 0; |
2531 | 2534 |
2532 SSLConfig ssl_config; | 2535 SSLConfig ssl_config; |
2533 StreamRequestWaiter waiter; | 2536 StreamRequestWaiter waiter; |
2534 std::unique_ptr<HttpStreamRequest> request( | 2537 std::unique_ptr<HttpStreamRequest> request( |
2535 session->http_stream_factory()->RequestBidirectionalStreamImpl( | 2538 session->http_stream_factory()->RequestBidirectionalStreamImpl( |
2536 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 2539 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
2537 NetLogWithSource())); | 2540 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2538 waiter.WaitForStream(); | 2541 waiter.WaitForStream(); |
2539 EXPECT_TRUE(waiter.stream_done()); | 2542 EXPECT_TRUE(waiter.stream_done()); |
2540 ASSERT_THAT(waiter.error_status(), IsError(ERR_FAILED)); | 2543 ASSERT_THAT(waiter.error_status(), IsError(ERR_FAILED)); |
2541 EXPECT_FALSE(waiter.websocket_stream()); | 2544 EXPECT_FALSE(waiter.websocket_stream()); |
2542 ASSERT_FALSE(waiter.stream()); | 2545 ASSERT_FALSE(waiter.stream()); |
2543 ASSERT_FALSE(waiter.bidirectional_stream_impl()); | 2546 ASSERT_FALSE(waiter.bidirectional_stream_impl()); |
2544 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetTransportSocketPool( | 2547 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetTransportSocketPool( |
2545 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2548 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2546 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSSLSocketPool( | 2549 EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSSLSocketPool( |
2547 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2550 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
(...skipping 27 matching lines...) Expand all Loading... |
2575 request_info.url = GURL("wss://www.google.com"); | 2578 request_info.url = GURL("wss://www.google.com"); |
2576 request_info.load_flags = 0; | 2579 request_info.load_flags = 0; |
2577 | 2580 |
2578 SSLConfig ssl_config; | 2581 SSLConfig ssl_config; |
2579 StreamRequestWaiter waiter1; | 2582 StreamRequestWaiter waiter1; |
2580 WebSocketStreamCreateHelper create_helper; | 2583 WebSocketStreamCreateHelper create_helper; |
2581 std::unique_ptr<HttpStreamRequest> request1( | 2584 std::unique_ptr<HttpStreamRequest> request1( |
2582 session->http_stream_factory_for_websocket() | 2585 session->http_stream_factory_for_websocket() |
2583 ->RequestWebSocketHandshakeStream( | 2586 ->RequestWebSocketHandshakeStream( |
2584 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1, | 2587 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1, |
2585 &create_helper, NetLogWithSource())); | 2588 &create_helper, |
| 2589 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2586 waiter1.WaitForStream(); | 2590 waiter1.WaitForStream(); |
2587 EXPECT_TRUE(waiter1.stream_done()); | 2591 EXPECT_TRUE(waiter1.stream_done()); |
2588 ASSERT_TRUE(nullptr != waiter1.websocket_stream()); | 2592 ASSERT_TRUE(nullptr != waiter1.websocket_stream()); |
2589 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, | 2593 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic, |
2590 waiter1.websocket_stream()->type()); | 2594 waiter1.websocket_stream()->type()); |
2591 EXPECT_TRUE(nullptr == waiter1.stream()); | 2595 EXPECT_TRUE(nullptr == waiter1.stream()); |
2592 | 2596 |
2593 EXPECT_EQ(0, GetSocketPoolGroupCount( | 2597 EXPECT_EQ(0, GetSocketPoolGroupCount( |
2594 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2598 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2595 EXPECT_EQ(0, GetSocketPoolGroupCount( | 2599 EXPECT_EQ(0, GetSocketPoolGroupCount( |
(...skipping 26 matching lines...) Expand all Loading... |
2622 request_info.url = GURL("wss://www.google.com"); | 2626 request_info.url = GURL("wss://www.google.com"); |
2623 request_info.load_flags = 0; | 2627 request_info.load_flags = 0; |
2624 | 2628 |
2625 SSLConfig ssl_config; | 2629 SSLConfig ssl_config; |
2626 StreamRequestWaiter waiter1; | 2630 StreamRequestWaiter waiter1; |
2627 WebSocketStreamCreateHelper create_helper; | 2631 WebSocketStreamCreateHelper create_helper; |
2628 std::unique_ptr<HttpStreamRequest> request1( | 2632 std::unique_ptr<HttpStreamRequest> request1( |
2629 session->http_stream_factory_for_websocket() | 2633 session->http_stream_factory_for_websocket() |
2630 ->RequestWebSocketHandshakeStream( | 2634 ->RequestWebSocketHandshakeStream( |
2631 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1, | 2635 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter1, |
2632 &create_helper, NetLogWithSource())); | 2636 &create_helper, |
| 2637 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2633 waiter1.WaitForStream(); | 2638 waiter1.WaitForStream(); |
2634 EXPECT_TRUE(waiter1.stream_done()); | 2639 EXPECT_TRUE(waiter1.stream_done()); |
2635 ASSERT_TRUE(nullptr != waiter1.websocket_stream()); | 2640 ASSERT_TRUE(nullptr != waiter1.websocket_stream()); |
2636 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy, | 2641 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy, |
2637 waiter1.websocket_stream()->type()); | 2642 waiter1.websocket_stream()->type()); |
2638 EXPECT_TRUE(nullptr == waiter1.stream()); | 2643 EXPECT_TRUE(nullptr == waiter1.stream()); |
2639 | 2644 |
2640 StreamRequestWaiter waiter2; | 2645 StreamRequestWaiter waiter2; |
2641 std::unique_ptr<HttpStreamRequest> request2( | 2646 std::unique_ptr<HttpStreamRequest> request2( |
2642 session->http_stream_factory_for_websocket() | 2647 session->http_stream_factory_for_websocket() |
2643 ->RequestWebSocketHandshakeStream( | 2648 ->RequestWebSocketHandshakeStream( |
2644 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2, | 2649 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter2, |
2645 &create_helper, NetLogWithSource())); | 2650 &create_helper, |
| 2651 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2646 waiter2.WaitForStream(); | 2652 waiter2.WaitForStream(); |
2647 EXPECT_TRUE(waiter2.stream_done()); | 2653 EXPECT_TRUE(waiter2.stream_done()); |
2648 ASSERT_TRUE(nullptr != waiter2.websocket_stream()); | 2654 ASSERT_TRUE(nullptr != waiter2.websocket_stream()); |
2649 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy, | 2655 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy, |
2650 waiter2.websocket_stream()->type()); | 2656 waiter2.websocket_stream()->type()); |
2651 EXPECT_TRUE(nullptr == waiter2.stream()); | 2657 EXPECT_TRUE(nullptr == waiter2.stream()); |
2652 EXPECT_NE(waiter2.websocket_stream(), waiter1.websocket_stream()); | 2658 EXPECT_NE(waiter2.websocket_stream(), waiter1.websocket_stream()); |
2653 EXPECT_EQ(static_cast<WebSocketSpdyHandshakeStream*>( | 2659 EXPECT_EQ(static_cast<WebSocketSpdyHandshakeStream*>( |
2654 waiter2.websocket_stream())->spdy_session(), | 2660 waiter2.websocket_stream())->spdy_session(), |
2655 static_cast<WebSocketSpdyHandshakeStream*>( | 2661 static_cast<WebSocketSpdyHandshakeStream*>( |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2701 host_port_pair.port()), | 2707 host_port_pair.port()), |
2702 AlternativeService(kProtoHTTP2, "www.google.com", 9999), expiration); | 2708 AlternativeService(kProtoHTTP2, "www.google.com", 9999), expiration); |
2703 | 2709 |
2704 SSLConfig ssl_config; | 2710 SSLConfig ssl_config; |
2705 StreamRequestWaiter waiter; | 2711 StreamRequestWaiter waiter; |
2706 WebSocketStreamCreateHelper create_helper; | 2712 WebSocketStreamCreateHelper create_helper; |
2707 std::unique_ptr<HttpStreamRequest> request( | 2713 std::unique_ptr<HttpStreamRequest> request( |
2708 session->http_stream_factory_for_websocket() | 2714 session->http_stream_factory_for_websocket() |
2709 ->RequestWebSocketHandshakeStream( | 2715 ->RequestWebSocketHandshakeStream( |
2710 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, | 2716 request_info, DEFAULT_PRIORITY, ssl_config, ssl_config, &waiter, |
2711 &create_helper, NetLogWithSource())); | 2717 &create_helper, |
| 2718 /* enable_ip_based_pooling = */ true, NetLogWithSource())); |
2712 waiter.WaitForStream(); | 2719 waiter.WaitForStream(); |
2713 EXPECT_TRUE(waiter.stream_done()); | 2720 EXPECT_TRUE(waiter.stream_done()); |
2714 EXPECT_TRUE(nullptr == waiter.stream()); | 2721 EXPECT_TRUE(nullptr == waiter.stream()); |
2715 ASSERT_TRUE(nullptr != waiter.websocket_stream()); | 2722 ASSERT_TRUE(nullptr != waiter.websocket_stream()); |
2716 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy, | 2723 EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy, |
2717 waiter.websocket_stream()->type()); | 2724 waiter.websocket_stream()->type()); |
2718 | 2725 |
2719 // Make sure that there was an alternative connection | 2726 // Make sure that there was an alternative connection |
2720 // which consumes extra connections. | 2727 // which consumes extra connections. |
2721 EXPECT_EQ(0, GetSocketPoolGroupCount( | 2728 EXPECT_EQ(0, GetSocketPoolGroupCount( |
2722 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2729 session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2723 EXPECT_EQ(0, GetSocketPoolGroupCount( | 2730 EXPECT_EQ(0, GetSocketPoolGroupCount( |
2724 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2731 session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2725 EXPECT_EQ(2, GetSocketPoolGroupCount( | 2732 EXPECT_EQ(2, GetSocketPoolGroupCount( |
2726 session->GetTransportSocketPool( | 2733 session->GetTransportSocketPool( |
2727 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); | 2734 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); |
2728 EXPECT_EQ(1, GetSocketPoolGroupCount( | 2735 EXPECT_EQ(1, GetSocketPoolGroupCount( |
2729 session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); | 2736 session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); |
2730 EXPECT_TRUE(waiter.used_proxy_info().is_direct()); | 2737 EXPECT_TRUE(waiter.used_proxy_info().is_direct()); |
2731 } | 2738 } |
2732 | 2739 |
2733 } // namespace | 2740 } // namespace |
2734 | 2741 |
2735 } // namespace net | 2742 } // namespace net |
OLD | NEW |