[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 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 |
| 3 | // found in the LICENSE file. |
| 4 | |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 5 | #include <algorithm> |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6 | #include <ostream> |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 7 | #include <string> |
| 8 | #include <utility> |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 9 | #include <vector> |
| 10 | |
Sebastien Marchand | 6d0558fd | 2019-01-25 16:49:37 | [diff] [blame] | 11 | #include "base/bind.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 12 | #include "base/compiler_specific.h" |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 13 | #include "base/macros.h" |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 14 | #include "base/run_loop.h" |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 15 | #include "base/stl_util.h" |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 16 | #include "base/strings/string_number_conversions.h" |
Bence Béky | d74f438 | 2018-02-20 18:26:19 | [diff] [blame] | 17 | #include "base/strings/string_piece.h" |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 18 | #include "base/strings/stringprintf.h" |
Devlin Cronin | e4bcb40e | 2018-06-05 18:02:47 | [diff] [blame] | 19 | #include "base/test/metrics/histogram_tester.h" |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 20 | #include "base/test/scoped_feature_list.h" |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 21 | #include "net/base/chunked_upload_data_stream.h" |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 22 | #include "net/base/completion_once_callback.h" |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 23 | #include "net/base/features.h" |
Tsuyoshi Horo | 01faed6 | 2019-02-20 22:11:37 | [diff] [blame] | 24 | #include "net/base/ip_endpoint.h" |
mgersh | af9a923 | 2017-04-13 20:19:03 | [diff] [blame] | 25 | #include "net/base/mock_network_change_notifier.h" |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 26 | #include "net/base/network_isolation_key.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 27 | #include "net/base/test_completion_callback.h" |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 28 | #include "net/base/test_proxy_delegate.h" |
rsleevi | d6de830 | 2016-06-21 01:33:20 | [diff] [blame] | 29 | #include "net/cert/ct_policy_enforcer.h" |
[email protected] | 6e7845ae | 2013-03-29 21:48:11 | [diff] [blame] | 30 | #include "net/cert/mock_cert_verifier.h" |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 31 | #include "net/cert/multi_log_ct_verifier.h" |
[email protected] | f2cb3cf | 2013-03-21 01:40:53 | [diff] [blame] | 32 | #include "net/dns/mock_host_resolver.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 33 | #include "net/http/http_auth_handler_factory.h" |
| 34 | #include "net/http/http_network_session.h" |
| 35 | #include "net/http/http_network_transaction.h" |
Matt Menke | 6e879bd | 2019-03-18 17:26:04 | [diff] [blame] | 36 | #include "net/http/http_proxy_connect_job.h" |
Matt Menke | 60916074 | 2019-08-02 18:47:26 | [diff] [blame] | 37 | #include "net/http/http_server_properties.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 38 | #include "net/http/http_stream.h" |
| 39 | #include "net/http/http_stream_factory.h" |
[email protected] | c41737d | 2014-05-14 07:47:19 | [diff] [blame] | 40 | #include "net/http/http_transaction_test_util.h" |
[email protected] | b1c988b | 2013-06-13 06:48:11 | [diff] [blame] | 41 | #include "net/http/transport_security_state.h" |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 42 | #include "net/log/net_log_event_type.h" |
vishal.b | 62985ca9 | 2015-04-17 08:45:51 | [diff] [blame] | 43 | #include "net/log/test_net_log.h" |
mmenke | 43758e6 | 2015-05-04 21:09:46 | [diff] [blame] | 44 | #include "net/log/test_net_log_util.h" |
Lily Houghton | 582d462 | 2018-01-22 22:43:40 | [diff] [blame] | 45 | #include "net/proxy_resolution/proxy_config_service_fixed.h" |
Lily Houghton | ffe89daa0 | 2018-03-09 18:30:03 | [diff] [blame] | 46 | #include "net/proxy_resolution/proxy_resolution_service.h" |
Lily Houghton | 582d462 | 2018-01-22 22:43:40 | [diff] [blame] | 47 | #include "net/proxy_resolution/proxy_resolver.h" |
Ryan Hamilton | a3ee93a7 | 2018-08-01 22:03:08 | [diff] [blame] | 48 | #include "net/quic/crypto/proof_verifier_chromium.h" |
| 49 | #include "net/quic/mock_crypto_client_stream_factory.h" |
| 50 | #include "net/quic/mock_quic_data.h" |
| 51 | #include "net/quic/quic_chromium_alarm_factory.h" |
| 52 | #include "net/quic/quic_http_stream.h" |
| 53 | #include "net/quic/quic_http_utils.h" |
| 54 | #include "net/quic/quic_stream_factory_peer.h" |
| 55 | #include "net/quic/quic_test_packet_maker.h" |
| 56 | #include "net/quic/test_task_runner.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 57 | #include "net/socket/client_socket_factory.h" |
| 58 | #include "net/socket/mock_client_socket_pool_manager.h" |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 59 | #include "net/socket/next_proto.h" |
tbansal | ca83c00 | 2016-04-28 20:56:28 | [diff] [blame] | 60 | #include "net/socket/socket_performance_watcher.h" |
| 61 | #include "net/socket/socket_performance_watcher_factory.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 62 | #include "net/socket/socket_test_util.h" |
Bence Béky | 94658bf | 2018-05-11 19:22:58 | [diff] [blame] | 63 | #include "net/spdy/spdy_test_util_common.h" |
[email protected] | 536fd0b | 2013-03-14 17:41:57 | [diff] [blame] | 64 | #include "net/ssl/ssl_config_service_defaults.h" |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 65 | #include "net/test/cert_test_util.h" |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 66 | #include "net/test/gtest_util.h" |
rsleevi | a69c79a | 2016-06-22 03:28:43 | [diff] [blame] | 67 | #include "net/test/test_data_directory.h" |
Gabriel Charette | c710874 | 2019-08-23 03:31:40 | [diff] [blame] | 68 | #include "net/test/test_with_task_environment.h" |
Victor Vasiliev | 6bb59d2 | 2019-03-08 21:34:51 | [diff] [blame] | 69 | #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h" |
| 70 | #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h" |
| 71 | #include "net/third_party/quiche/src/quic/core/quic_framer.h" |
| 72 | #include "net/third_party/quiche/src/quic/core/quic_utils.h" |
| 73 | #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h" |
| 74 | #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" |
| 75 | #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" |
| 76 | #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h" |
| 77 | #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h" |
| 78 | #include "net/third_party/quiche/src/quic/test_tools/mock_random.h" |
| 79 | #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h" |
| 80 | #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" |
Victor Vasiliev | 27cc771 | 2019-01-24 11:50:14 | [diff] [blame] | 81 | #include "net/third_party/quiche/src/spdy/core/spdy_frame_builder.h" |
| 82 | #include "net/third_party/quiche/src/spdy/core/spdy_framer.h" |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 83 | #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" |
Matt Menke | d732ea4 | 2019-03-08 12:05:00 | [diff] [blame] | 84 | #include "net/url_request/static_http_user_agent_settings.h" |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 85 | #include "net/url_request/url_request.h" |
| 86 | #include "net/url_request/url_request_job_factory_impl.h" |
| 87 | #include "net/url_request/url_request_test_util.h" |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 88 | #include "testing/gmock/include/gmock/gmock.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 89 | #include "testing/gtest/include/gtest/gtest.h" |
| 90 | #include "testing/platform_test.h" |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 91 | #include "url/gurl.h" |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 92 | #include "url/origin.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 93 | |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 94 | using ::testing::ElementsAre; |
| 95 | using ::testing::Key; |
| 96 | |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 97 | namespace net { |
| 98 | namespace test { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 99 | |
| 100 | namespace { |
| 101 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 102 | enum DestinationType { |
| 103 | // In pooling tests with two requests for different origins to the same |
| 104 | // destination, the destination should be |
| 105 | SAME_AS_FIRST, // the same as the first origin, |
| 106 | SAME_AS_SECOND, // the same as the second origin, or |
| 107 | DIFFERENT, // different from both. |
| 108 | }; |
| 109 | |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 110 | static const char kQuicAlternativeServiceHeader[] = |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 111 | "Alt-Svc: quic=\":443\"\r\n\r\n"; |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 112 | static const char kQuicAlternativeServiceWithProbabilityHeader[] = |
| 113 | "Alt-Svc: quic=\":443\";p=\".5\"\r\n\r\n"; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 114 | static const char kQuicAlternativeServiceDifferentPortHeader[] = |
| 115 | "Alt-Svc: quic=\":137\"\r\n\r\n"; |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 116 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 117 | const char kDefaultServerHostName[] = "mail.example.org"; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 118 | const char kDifferentHostname[] = "different.example.com"; |
| 119 | |
| 120 | // Run QuicNetworkTransactionWithDestinationTest instances with all value |
| 121 | // combinations of version and destination_type. |
| 122 | struct PoolingTestParams { |
| 123 | friend std::ostream& operator<<(std::ostream& os, |
| 124 | const PoolingTestParams& p) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 125 | os << "{ version: " << ParsedQuicVersionToString(p.version) |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 126 | << ", destination_type: "; |
| 127 | switch (p.destination_type) { |
| 128 | case SAME_AS_FIRST: |
| 129 | os << "SAME_AS_FIRST"; |
| 130 | break; |
| 131 | case SAME_AS_SECOND: |
| 132 | os << "SAME_AS_SECOND"; |
| 133 | break; |
| 134 | case DIFFERENT: |
| 135 | os << "DIFFERENT"; |
| 136 | break; |
| 137 | } |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 138 | os << ", client_headers_include_h2_stream_dependency: " |
| 139 | << p.client_headers_include_h2_stream_dependency; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 140 | os << " }"; |
| 141 | return os; |
| 142 | } |
| 143 | |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 144 | quic::ParsedQuicVersion version; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 145 | DestinationType destination_type; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 146 | bool client_headers_include_h2_stream_dependency; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 147 | }; |
| 148 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 149 | std::string GenerateQuicVersionsListForAltSvcHeader( |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 150 | const quic::ParsedQuicVersionVector& versions) { |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 151 | std::string result = ""; |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 152 | for (const quic::ParsedQuicVersion& version : versions) { |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 153 | if (!result.empty()) |
| 154 | result.append(","); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 155 | result.append(base::NumberToString(version.transport_version)); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 156 | } |
| 157 | return result; |
| 158 | } |
| 159 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 160 | std::vector<PoolingTestParams> GetPoolingTestParams() { |
| 161 | std::vector<PoolingTestParams> params; |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 162 | quic::ParsedQuicVersionVector all_supported_versions = |
Ryan Hamilton | 93424eb8 | 2019-08-23 04:28:40 | [diff] [blame] | 163 | quic::AllSupportedVersions(); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 164 | for (const quic::ParsedQuicVersion version : all_supported_versions) { |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 165 | // TODO(rch): crbug.com/978745 - Make this work with TLS |
| 166 | if (version.handshake_protocol != quic::PROTOCOL_TLS1_3) { |
| 167 | params.push_back(PoolingTestParams{version, SAME_AS_FIRST, false}); |
| 168 | params.push_back(PoolingTestParams{version, SAME_AS_FIRST, true}); |
| 169 | params.push_back(PoolingTestParams{version, SAME_AS_SECOND, false}); |
| 170 | params.push_back(PoolingTestParams{version, SAME_AS_SECOND, true}); |
| 171 | params.push_back(PoolingTestParams{version, DIFFERENT, false}); |
| 172 | params.push_back(PoolingTestParams{version, DIFFERENT, true}); |
| 173 | } |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 174 | } |
| 175 | return params; |
| 176 | } |
bnc | b07c0553 | 2015-05-14 19:07:20 | [diff] [blame] | 177 | |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 178 | } // namespace |
| 179 | |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 180 | class HeadersHandler { |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 181 | public: |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 182 | HeadersHandler() : was_proxied_(false) {} |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 183 | |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 184 | bool was_proxied() { return was_proxied_; } |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 185 | |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 186 | void OnBeforeHeadersSent(const ProxyInfo& proxy_info, |
| 187 | HttpRequestHeaders* request_headers) { |
| 188 | if (!proxy_info.is_http() && !proxy_info.is_https() && |
| 189 | !proxy_info.is_quic()) { |
| 190 | return; |
| 191 | } |
| 192 | was_proxied_ = true; |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 193 | } |
| 194 | |
| 195 | private: |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 196 | bool was_proxied_; |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 197 | }; |
| 198 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 199 | class TestSocketPerformanceWatcher : public SocketPerformanceWatcher { |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 200 | public: |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 201 | TestSocketPerformanceWatcher(bool* should_notify_updated_rtt, |
| 202 | bool* rtt_notification_received) |
| 203 | : should_notify_updated_rtt_(should_notify_updated_rtt), |
| 204 | rtt_notification_received_(rtt_notification_received) {} |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 205 | ~TestSocketPerformanceWatcher() override {} |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 206 | |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 207 | bool ShouldNotifyUpdatedRTT() const override { |
| 208 | return *should_notify_updated_rtt_; |
| 209 | } |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 210 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 211 | void OnUpdatedRTTAvailable(const base::TimeDelta& rtt) override { |
| 212 | *rtt_notification_received_ = true; |
| 213 | } |
| 214 | |
| 215 | void OnConnectionChanged() override {} |
| 216 | |
| 217 | private: |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 218 | bool* should_notify_updated_rtt_; |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 219 | bool* rtt_notification_received_; |
| 220 | |
| 221 | DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcher); |
| 222 | }; |
| 223 | |
| 224 | class TestSocketPerformanceWatcherFactory |
| 225 | : public SocketPerformanceWatcherFactory { |
| 226 | public: |
| 227 | TestSocketPerformanceWatcherFactory() |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 228 | : watcher_count_(0u), |
| 229 | should_notify_updated_rtt_(true), |
| 230 | rtt_notification_received_(false) {} |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 231 | ~TestSocketPerformanceWatcherFactory() override {} |
| 232 | |
| 233 | // SocketPerformanceWatcherFactory implementation: |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 234 | std::unique_ptr<SocketPerformanceWatcher> CreateSocketPerformanceWatcher( |
Tarun Bansal | 73a0437 | 2017-07-27 16:28:41 | [diff] [blame] | 235 | const Protocol protocol, |
| 236 | const AddressList& /* address_list */) override { |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 237 | if (protocol != PROTOCOL_QUIC) { |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 238 | return nullptr; |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 239 | } |
| 240 | ++watcher_count_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 241 | return std::unique_ptr<SocketPerformanceWatcher>( |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 242 | new TestSocketPerformanceWatcher(&should_notify_updated_rtt_, |
| 243 | &rtt_notification_received_)); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 244 | } |
| 245 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 246 | size_t watcher_count() const { return watcher_count_; } |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 247 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 248 | bool rtt_notification_received() const { return rtt_notification_received_; } |
| 249 | |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 250 | void set_should_notify_updated_rtt(bool should_notify_updated_rtt) { |
| 251 | should_notify_updated_rtt_ = should_notify_updated_rtt; |
| 252 | } |
| 253 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 254 | private: |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 255 | size_t watcher_count_; |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 256 | bool should_notify_updated_rtt_; |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 257 | bool rtt_notification_received_; |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 258 | |
| 259 | DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcherFactory); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 260 | }; |
| 261 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 262 | class QuicNetworkTransactionTest |
| 263 | : public PlatformTest, |
| 264 | public ::testing::WithParamInterface< |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 265 | std::tuple<quic::ParsedQuicVersion, bool>>, |
Gabriel Charette | 694c3c33 | 2019-08-19 14:53:05 | [diff] [blame] | 266 | public WithTaskEnvironment { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 267 | protected: |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 268 | QuicNetworkTransactionTest() |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 269 | : version_(std::get<0>(GetParam())), |
| 270 | client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())), |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 271 | supported_versions_(quic::test::SupportedVersions(version_)), |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 272 | random_generator_(0), |
| 273 | client_maker_( |
| 274 | version_, |
| 275 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 276 | &clock_, |
| 277 | kDefaultServerHostName, |
| 278 | quic::Perspective::IS_CLIENT, |
| 279 | client_headers_include_h2_stream_dependency_), |
| 280 | server_maker_( |
| 281 | version_, |
| 282 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 283 | &clock_, |
| 284 | kDefaultServerHostName, |
| 285 | quic::Perspective::IS_SERVER, |
| 286 | false), |
Nick Harper | eb483e1 | 2019-05-14 00:18:09 | [diff] [blame] | 287 | quic_task_runner_(new TestTaskRunner(&clock_)), |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 288 | cert_transparency_verifier_(new MultiLogCTVerifier()), |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 289 | ssl_config_service_(new SSLConfigServiceDefaults), |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 290 | proxy_resolution_service_(ProxyResolutionService::CreateDirect()), |
Eric Orth | be2efac | 2019-03-06 01:11:11 | [diff] [blame] | 291 | auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()), |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 292 | http_server_properties_(std::make_unique<HttpServerProperties>()), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 293 | ssl_data_(ASYNC, OK) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 294 | request_.method = "GET"; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 295 | std::string url("https://"); |
bnc | b07c0553 | 2015-05-14 19:07:20 | [diff] [blame] | 296 | url.append(kDefaultServerHostName); |
| 297 | request_.url = GURL(url); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 298 | request_.load_flags = 0; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 299 | request_.traffic_annotation = |
| 300 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 301 | clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20)); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 302 | |
| 303 | scoped_refptr<X509Certificate> cert( |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 304 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 305 | verify_details_.cert_verify_result.verified_cert = cert; |
| 306 | verify_details_.cert_verify_result.is_issued_by_known_root = true; |
| 307 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 308 | } |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 309 | |
dcheng | 67be2b1f | 2014-10-27 21:47:29 | [diff] [blame] | 310 | void SetUp() override { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 311 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 312 | base::RunLoop().RunUntilIdle(); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 313 | } |
| 314 | |
dcheng | 67be2b1f | 2014-10-27 21:47:29 | [diff] [blame] | 315 | void TearDown() override { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 316 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 317 | // Empty the current queue. |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 318 | base::RunLoop().RunUntilIdle(); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 319 | PlatformTest::TearDown(); |
| 320 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 321 | base::RunLoop().RunUntilIdle(); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 322 | session_.reset(); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 323 | } |
| 324 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 325 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 326 | ConstructClientConnectionClosePacket(uint64_t num) { |
Bin Wu | 5311aca | 2018-01-22 01:19:03 | [diff] [blame] | 327 | return client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 328 | num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 329 | } |
| 330 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 331 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 332 | ConstructServerConnectionClosePacket(uint64_t num) { |
Bin Wu | 5311aca | 2018-01-22 01:19:03 | [diff] [blame] | 333 | return server_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 334 | num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"); |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 335 | } |
| 336 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 337 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerGoAwayPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 338 | uint64_t num, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 339 | quic::QuicErrorCode error_code, |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 340 | std::string reason_phrase) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 341 | return server_maker_.MakeGoAwayPacket(num, error_code, reason_phrase); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 342 | } |
| 343 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 344 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 345 | uint64_t packet_number, |
| 346 | uint64_t largest_received, |
| 347 | uint64_t smallest_received, |
| 348 | uint64_t least_unacked) { |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 349 | return client_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 350 | smallest_received, least_unacked, true); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 351 | } |
| 352 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 353 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 354 | uint64_t packet_number, |
| 355 | uint64_t largest_received, |
| 356 | uint64_t smallest_received, |
| 357 | uint64_t least_unacked, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 358 | quic::QuicTime::Delta ack_delay_time) { |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 359 | return client_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 360 | smallest_received, least_unacked, true, |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 361 | ack_delay_time); |
| 362 | } |
| 363 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 364 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckAndRstPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 365 | uint64_t num, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 366 | quic::QuicStreamId stream_id, |
| 367 | quic::QuicRstStreamErrorCode error_code, |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 368 | uint64_t largest_received, |
| 369 | uint64_t smallest_received, |
| 370 | uint64_t least_unacked) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 371 | return client_maker_.MakeAckAndRstPacket( |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 372 | num, false, stream_id, error_code, largest_received, smallest_received, |
| 373 | least_unacked, true); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 374 | } |
| 375 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 376 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientRstPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 377 | uint64_t num, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 378 | quic::QuicStreamId stream_id, |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 379 | quic::QuicRstStreamErrorCode error_code) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 380 | return client_maker_.MakeRstPacket(num, false, stream_id, error_code, |
Frank Kastenholz | 684ea41 | 2019-02-13 18:48:18 | [diff] [blame] | 381 | /*include_stop_sending_if_v99=*/true); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 382 | } |
| 383 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 384 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 385 | ConstructClientAckAndConnectionClosePacket(uint64_t packet_number, |
| 386 | uint64_t largest_received, |
| 387 | uint64_t smallest_received, |
| 388 | uint64_t least_unacked) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 389 | return client_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 390 | smallest_received, least_unacked, true); |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 391 | } |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 392 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 393 | std::unique_ptr<quic::QuicEncryptedPacket> |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 394 | ConstructClientAckAndConnectionClosePacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 395 | uint64_t num, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 396 | quic::QuicTime::Delta delta_time_largest_observed, |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 397 | uint64_t largest_received, |
| 398 | uint64_t smallest_received, |
| 399 | uint64_t least_unacked, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 400 | quic::QuicErrorCode quic_error, |
Renjie Tang | ff0d637 | 2019-08-30 22:03:29 | [diff] [blame] | 401 | const std::string& quic_error_details, |
| 402 | uint64_t frame_type) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 403 | return client_maker_.MakeAckAndConnectionClosePacket( |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 404 | num, false, delta_time_largest_observed, largest_received, |
Renjie Tang | ff0d637 | 2019-08-30 22:03:29 | [diff] [blame] | 405 | smallest_received, least_unacked, quic_error, quic_error_details, |
| 406 | frame_type); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 407 | } |
| 408 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 409 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerRstPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 410 | uint64_t num, |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 411 | bool include_version, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 412 | quic::QuicStreamId stream_id, |
| 413 | quic::QuicRstStreamErrorCode error_code) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 414 | return server_maker_.MakeRstPacket(num, include_version, stream_id, |
| 415 | error_code); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 416 | } |
| 417 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 418 | std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 419 | uint64_t packet_number) { |
| 420 | return client_maker_.MakeInitialSettingsPacket(packet_number); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 421 | } |
| 422 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 423 | std::unique_ptr<quic::QuicReceivedPacket> ConstructServerAckPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 424 | uint64_t packet_number, |
| 425 | uint64_t largest_received, |
| 426 | uint64_t smallest_received, |
| 427 | uint64_t least_unacked) { |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 428 | return server_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 429 | smallest_received, least_unacked, false); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 430 | } |
| 431 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 432 | std::unique_ptr<quic::QuicReceivedPacket> ConstructClientPriorityPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 433 | uint64_t packet_number, |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 434 | bool should_include_version, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 435 | quic::QuicStreamId id, |
| 436 | quic::QuicStreamId parent_stream_id, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 437 | RequestPriority request_priority) { |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 438 | return client_maker_.MakePriorityPacket( |
| 439 | packet_number, should_include_version, id, parent_stream_id, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 440 | ConvertRequestPriorityToQuicPriority(request_priority)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 441 | } |
| 442 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 443 | std::unique_ptr<quic::QuicEncryptedPacket> |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 444 | ConstructClientAckAndPriorityFramesPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 445 | uint64_t packet_number, |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 446 | bool should_include_version, |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 447 | uint64_t largest_received, |
| 448 | uint64_t smallest_received, |
| 449 | uint64_t least_unacked, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 450 | const std::vector<QuicTestPacketMaker::Http2StreamDependency>& |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 451 | priority_frames) { |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 452 | return client_maker_.MakeAckAndMultiplePriorityFramesPacket( |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 453 | packet_number, should_include_version, largest_received, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 454 | smallest_received, least_unacked, priority_frames); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 455 | } |
| 456 | |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 457 | // Uses default QuicTestPacketMaker. |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 458 | spdy::SpdyHeaderBlock GetRequestHeaders(const std::string& method, |
| 459 | const std::string& scheme, |
| 460 | const std::string& path) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 461 | return GetRequestHeaders(method, scheme, path, &client_maker_); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 462 | } |
| 463 | |
| 464 | // Uses customized QuicTestPacketMaker. |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 465 | spdy::SpdyHeaderBlock GetRequestHeaders(const std::string& method, |
| 466 | const std::string& scheme, |
| 467 | const std::string& path, |
| 468 | QuicTestPacketMaker* maker) { |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 469 | return maker->GetRequestHeaders(method, scheme, path); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 470 | } |
| 471 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 472 | spdy::SpdyHeaderBlock ConnectRequestHeaders(const std::string& host_port) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 473 | return client_maker_.ConnectRequestHeaders(host_port); |
| 474 | } |
| 475 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 476 | spdy::SpdyHeaderBlock GetResponseHeaders(const std::string& status) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 477 | return server_maker_.GetResponseHeaders(status); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 478 | } |
| 479 | |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 480 | // Appends alt_svc headers in the response headers. |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 481 | spdy::SpdyHeaderBlock GetResponseHeaders(const std::string& status, |
| 482 | const std::string& alt_svc) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 483 | return server_maker_.GetResponseHeaders(status, alt_svc); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 484 | } |
| 485 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 486 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 487 | uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 488 | quic::QuicStreamId stream_id, |
[email protected] | e8ff2684 | 2013-03-22 21:02:05 | [diff] [blame] | 489 | bool should_include_version, |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 490 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 491 | quic::QuicStringPiece data) { |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 492 | return server_maker_.MakeDataPacket(packet_number, stream_id, |
| 493 | should_include_version, fin, data); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 494 | } |
| 495 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 496 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientDataPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 497 | uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 498 | quic::QuicStreamId stream_id, |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 499 | bool should_include_version, |
| 500 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 501 | quic::QuicStringPiece data) { |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 502 | return client_maker_.MakeDataPacket(packet_number, stream_id, |
| 503 | should_include_version, fin, data); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 504 | } |
| 505 | |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 506 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 507 | ConstructClientMultipleDataFramesPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 508 | uint64_t packet_number, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 509 | quic::QuicStreamId stream_id, |
| 510 | bool should_include_version, |
| 511 | bool fin, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 512 | const std::vector<std::string> data_writes) { |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 513 | return client_maker_.MakeMultipleDataFramesPacket( |
| 514 | packet_number, stream_id, should_include_version, fin, data_writes); |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 515 | } |
| 516 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 517 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckAndDataPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 518 | uint64_t packet_number, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 519 | bool include_version, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 520 | quic::QuicStreamId stream_id, |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 521 | uint64_t largest_received, |
| 522 | uint64_t smallest_received, |
| 523 | uint64_t least_unacked, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 524 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 525 | quic::QuicStringPiece data) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 526 | return client_maker_.MakeAckAndDataPacket( |
| 527 | packet_number, include_version, stream_id, largest_received, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 528 | smallest_received, least_unacked, fin, data); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 529 | } |
| 530 | |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 531 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 532 | ConstructClientAckAndMultipleDataFramesPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 533 | uint64_t packet_number, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 534 | bool include_version, |
| 535 | quic::QuicStreamId stream_id, |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 536 | uint64_t largest_received, |
| 537 | uint64_t smallest_received, |
| 538 | uint64_t least_unacked, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 539 | bool fin, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 540 | const std::vector<std::string> data_writes) { |
| 541 | return client_maker_.MakeAckAndMultipleDataFramesPacket( |
| 542 | packet_number, include_version, stream_id, largest_received, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 543 | smallest_received, least_unacked, fin, data_writes); |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 544 | } |
| 545 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 546 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientForceHolDataPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 547 | uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 548 | quic::QuicStreamId stream_id, |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 549 | bool should_include_version, |
| 550 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 551 | quic::QuicStreamOffset* offset, |
| 552 | quic::QuicStringPiece data) { |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 553 | return client_maker_.MakeForceHolDataPacket( |
| 554 | packet_number, stream_id, should_include_version, fin, offset, data); |
| 555 | } |
| 556 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 557 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 558 | ConstructClientRequestHeadersPacket(uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 559 | quic::QuicStreamId stream_id, |
| 560 | bool should_include_version, |
| 561 | bool fin, |
| 562 | spdy::SpdyHeaderBlock headers) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 563 | return ConstructClientRequestHeadersPacket(packet_number, stream_id, |
| 564 | should_include_version, fin, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 565 | std::move(headers), 0); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 566 | } |
| 567 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 568 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 569 | ConstructClientRequestHeadersPacket(uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 570 | quic::QuicStreamId stream_id, |
| 571 | bool should_include_version, |
| 572 | bool fin, |
| 573 | spdy::SpdyHeaderBlock headers, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 574 | quic::QuicStreamId parent_stream_id) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 575 | return ConstructClientRequestHeadersPacket( |
| 576 | packet_number, stream_id, should_include_version, fin, DEFAULT_PRIORITY, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 577 | std::move(headers), parent_stream_id); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 578 | } |
| 579 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 580 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 581 | ConstructClientRequestHeadersPacket(uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 582 | quic::QuicStreamId stream_id, |
| 583 | bool should_include_version, |
| 584 | bool fin, |
| 585 | RequestPriority request_priority, |
| 586 | spdy::SpdyHeaderBlock headers, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 587 | quic::QuicStreamId parent_stream_id) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 588 | spdy::SpdyPriority priority = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 589 | ConvertRequestPriorityToQuicPriority(request_priority); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 590 | return client_maker_.MakeRequestHeadersPacket( |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 591 | packet_number, stream_id, should_include_version, fin, priority, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 592 | std::move(headers), parent_stream_id, nullptr); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 593 | } |
| 594 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 595 | std::unique_ptr<quic::QuicReceivedPacket> |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 596 | ConstructClientRequestHeadersAndDataFramesPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 597 | uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 598 | quic::QuicStreamId stream_id, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 599 | bool should_include_version, |
| 600 | bool fin, |
| 601 | RequestPriority request_priority, |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 602 | spdy::SpdyHeaderBlock headers, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 603 | quic::QuicStreamId parent_stream_id, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 604 | size_t* spdy_headers_frame_length, |
| 605 | const std::vector<std::string>& data_writes) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 606 | spdy::SpdyPriority priority = |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 607 | ConvertRequestPriorityToQuicPriority(request_priority); |
| 608 | return client_maker_.MakeRequestHeadersAndMultipleDataFramesPacket( |
| 609 | packet_number, stream_id, should_include_version, fin, priority, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 610 | std::move(headers), parent_stream_id, spdy_headers_frame_length, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 611 | data_writes); |
| 612 | } |
| 613 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 614 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerPushPromisePacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 615 | uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 616 | quic::QuicStreamId stream_id, |
| 617 | quic::QuicStreamId promised_stream_id, |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 618 | bool should_include_version, |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 619 | spdy::SpdyHeaderBlock headers, |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 620 | QuicTestPacketMaker* maker) { |
| 621 | return maker->MakePushPromisePacket( |
| 622 | packet_number, stream_id, promised_stream_id, should_include_version, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 623 | false, std::move(headers), nullptr); |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 624 | } |
| 625 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 626 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 627 | ConstructServerResponseHeadersPacket(uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 628 | quic::QuicStreamId stream_id, |
| 629 | bool should_include_version, |
| 630 | bool fin, |
| 631 | spdy::SpdyHeaderBlock headers) { |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 632 | return server_maker_.MakeResponseHeadersPacket(packet_number, stream_id, |
| 633 | should_include_version, fin, |
| 634 | std::move(headers), nullptr); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 635 | } |
| 636 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 637 | std::string ConstructDataHeader(size_t body_len) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 638 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 639 | return ""; |
| 640 | } |
| 641 | quic::HttpEncoder encoder; |
| 642 | std::unique_ptr<char[]> buffer; |
| 643 | auto header_length = encoder.SerializeDataFrameHeader(body_len, &buffer); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 644 | return std::string(buffer.get(), header_length); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 645 | } |
| 646 | |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 647 | void CreateSession(const quic::ParsedQuicVersionVector& supported_versions) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 648 | session_params_.enable_quic = true; |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 649 | session_params_.quic_params.supported_versions = supported_versions; |
Bence Béky | 1ceba55 | 2019-07-19 17:11:05 | [diff] [blame] | 650 | session_params_.quic_params.max_allowed_push_id = quic::kMaxQuicStreamId; |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 651 | session_params_.quic_params.headers_include_h2_stream_dependency = |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 652 | client_headers_include_h2_stream_dependency_; |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 653 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 654 | session_context_.quic_clock = &clock_; |
| 655 | session_context_.quic_random = &random_generator_; |
| 656 | session_context_.client_socket_factory = &socket_factory_; |
| 657 | session_context_.quic_crypto_client_stream_factory = |
| 658 | &crypto_client_stream_factory_; |
| 659 | session_context_.host_resolver = &host_resolver_; |
| 660 | session_context_.cert_verifier = &cert_verifier_; |
| 661 | session_context_.transport_security_state = &transport_security_state_; |
| 662 | session_context_.cert_transparency_verifier = |
| 663 | cert_transparency_verifier_.get(); |
| 664 | session_context_.ct_policy_enforcer = &ct_policy_enforcer_; |
| 665 | session_context_.socket_performance_watcher_factory = |
| 666 | &test_socket_performance_watcher_factory_; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 667 | session_context_.proxy_resolution_service = proxy_resolution_service_.get(); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 668 | session_context_.ssl_config_service = ssl_config_service_.get(); |
| 669 | session_context_.http_auth_handler_factory = auth_handler_factory_.get(); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 670 | session_context_.http_server_properties = http_server_properties_.get(); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 671 | session_context_.net_log = net_log_.bound().net_log(); |
| 672 | |
| 673 | session_.reset(new HttpNetworkSession(session_params_, session_context_)); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 674 | session_->quic_stream_factory()->set_require_confirmation(false); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 675 | SpdySessionPoolPeer spdy_pool_peer(session_->spdy_session_pool()); |
| 676 | spdy_pool_peer.SetEnableSendingInitialData(false); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 677 | } |
| 678 | |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 679 | void CreateSession() { return CreateSession(supported_versions_); } |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 680 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 681 | void CheckWasQuicResponse(HttpNetworkTransaction* trans) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 682 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 683 | ASSERT_TRUE(response != nullptr); |
| 684 | ASSERT_TRUE(response->headers.get() != nullptr); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 685 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 686 | EXPECT_TRUE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 687 | EXPECT_TRUE(response->was_alpn_negotiated); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 688 | EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion( |
| 689 | version_.transport_version), |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 690 | response->connection_info); |
| 691 | } |
| 692 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 693 | void CheckResponsePort(HttpNetworkTransaction* trans, uint16_t port) { |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 694 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 695 | ASSERT_TRUE(response != nullptr); |
Tsuyoshi Horo | 01faed6 | 2019-02-20 22:11:37 | [diff] [blame] | 696 | EXPECT_EQ(port, response->remote_endpoint.port()); |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 697 | } |
| 698 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 699 | void CheckWasHttpResponse(HttpNetworkTransaction* trans) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 700 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 701 | ASSERT_TRUE(response != nullptr); |
| 702 | ASSERT_TRUE(response->headers.get() != nullptr); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 703 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 704 | EXPECT_FALSE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 705 | EXPECT_FALSE(response->was_alpn_negotiated); |
mmenke | 8210acc | 2016-07-11 16:34:52 | [diff] [blame] | 706 | EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1_1, |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 707 | response->connection_info); |
| 708 | } |
| 709 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 710 | void CheckWasSpdyResponse(HttpNetworkTransaction* trans) { |
| 711 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 712 | ASSERT_TRUE(response != nullptr); |
| 713 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 714 | EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); |
| 715 | EXPECT_TRUE(response->was_fetched_via_spdy); |
| 716 | EXPECT_TRUE(response->was_alpn_negotiated); |
| 717 | EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP2, |
| 718 | response->connection_info); |
| 719 | } |
| 720 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 721 | void CheckResponseData(HttpNetworkTransaction* trans, |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 722 | const std::string& expected) { |
| 723 | std::string response_data; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 724 | ASSERT_THAT(ReadTransaction(trans, &response_data), IsOk()); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 725 | EXPECT_EQ(expected, response_data); |
| 726 | } |
| 727 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 728 | void RunTransaction(HttpNetworkTransaction* trans) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 729 | TestCompletionCallback callback; |
| 730 | int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 731 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 732 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 733 | } |
| 734 | |
| 735 | void SendRequestAndExpectHttpResponse(const std::string& expected) { |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 736 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 737 | RunTransaction(&trans); |
| 738 | CheckWasHttpResponse(&trans); |
| 739 | CheckResponseData(&trans, expected); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 740 | } |
| 741 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 742 | void SendRequestAndExpectHttpResponseFromProxy(const std::string& expected, |
| 743 | bool used_proxy, |
| 744 | uint16_t port) { |
| 745 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 746 | HeadersHandler headers_handler; |
| 747 | trans.SetBeforeHeadersSentCallback( |
| 748 | base::Bind(&HeadersHandler::OnBeforeHeadersSent, |
| 749 | base::Unretained(&headers_handler))); |
| 750 | RunTransaction(&trans); |
| 751 | CheckWasHttpResponse(&trans); |
| 752 | CheckResponsePort(&trans, port); |
| 753 | CheckResponseData(&trans, expected); |
| 754 | EXPECT_EQ(used_proxy, headers_handler.was_proxied()); |
tbansal | 2ecbbc7 | 2016-10-06 17:15:47 | [diff] [blame] | 755 | if (used_proxy) { |
| 756 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_https()); |
| 757 | } else { |
| 758 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_direct()); |
| 759 | } |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 760 | } |
| 761 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 762 | void SendRequestAndExpectQuicResponse(const std::string& expected) { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 763 | SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, 443); |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 764 | } |
| 765 | |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 766 | void SendRequestAndExpectQuicResponseFromProxyOnPort( |
| 767 | const std::string& expected, |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 768 | uint16_t port) { |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 769 | SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 770 | } |
| 771 | |
| 772 | void AddQuicAlternateProtocolMapping( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 773 | MockCryptoClientStream::HandshakeMode handshake_mode) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 774 | crypto_client_stream_factory_.set_handshake_mode(handshake_mode); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 775 | url::SchemeHostPort server(request_.url); |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 776 | AlternativeService alternative_service(kProtoQUIC, server.host(), 443); |
bnc | 7dc7e1b4 | 2015-07-28 14:43:12 | [diff] [blame] | 777 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 778 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 779 | server, NetworkIsolationKey(), alternative_service, expiration, |
| 780 | supported_versions_); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 781 | } |
| 782 | |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 783 | void AddQuicRemoteAlternativeServiceMapping( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 784 | MockCryptoClientStream::HandshakeMode handshake_mode, |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 785 | const HostPortPair& alternative) { |
| 786 | crypto_client_stream_factory_.set_handshake_mode(handshake_mode); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 787 | url::SchemeHostPort server(request_.url); |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 788 | AlternativeService alternative_service(kProtoQUIC, alternative.host(), |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 789 | alternative.port()); |
| 790 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 791 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 792 | server, NetworkIsolationKey(), alternative_service, expiration, |
| 793 | supported_versions_); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 794 | } |
| 795 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 796 | void ExpectBrokenAlternateProtocolMapping() { |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 797 | const url::SchemeHostPort server(request_.url); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 798 | const AlternativeServiceInfoVector alternative_service_info_vector = |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 799 | http_server_properties_->GetAlternativeServiceInfos( |
| 800 | server, NetworkIsolationKey()); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 801 | EXPECT_EQ(1u, alternative_service_info_vector.size()); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 802 | EXPECT_TRUE(http_server_properties_->IsAlternativeServiceBroken( |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 803 | alternative_service_info_vector[0].alternative_service())); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 804 | } |
| 805 | |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 806 | void ExpectQuicAlternateProtocolMapping() { |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 807 | const url::SchemeHostPort server(request_.url); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 808 | const AlternativeServiceInfoVector alternative_service_info_vector = |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 809 | http_server_properties_->GetAlternativeServiceInfos( |
| 810 | server, NetworkIsolationKey()); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 811 | EXPECT_EQ(1u, alternative_service_info_vector.size()); |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 812 | EXPECT_EQ( |
| 813 | kProtoQUIC, |
| 814 | alternative_service_info_vector[0].alternative_service().protocol); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 815 | EXPECT_FALSE(http_server_properties_->IsAlternativeServiceBroken( |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 816 | alternative_service_info_vector[0].alternative_service())); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 817 | } |
| 818 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 819 | void AddHangingNonAlternateProtocolSocketData() { |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 820 | std::unique_ptr<StaticSocketDataProvider> hanging_data; |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 821 | hanging_data.reset(new StaticSocketDataProvider()); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 822 | MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 823 | hanging_data->set_connect_data(hanging_connect); |
| 824 | hanging_data_.push_back(std::move(hanging_data)); |
| 825 | socket_factory_.AddSocketDataProvider(hanging_data_.back().get()); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 826 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 827 | } |
| 828 | |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 829 | void SetUpTestForRetryConnectionOnAlternateNetwork() { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 830 | session_params_.quic_params.migrate_sessions_on_network_change_v2 = true; |
| 831 | session_params_.quic_params.migrate_sessions_early_v2 = true; |
| 832 | session_params_.quic_params.retry_on_alternate_network_before_handshake = |
| 833 | true; |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 834 | scoped_mock_change_notifier_.reset(new ScopedMockNetworkChangeNotifier()); |
| 835 | MockNetworkChangeNotifier* mock_ncn = |
| 836 | scoped_mock_change_notifier_->mock_network_change_notifier(); |
| 837 | mock_ncn->ForceNetworkHandlesSupported(); |
| 838 | mock_ncn->SetConnectedNetworksList( |
| 839 | {kDefaultNetworkForTests, kNewNetworkForTests}); |
| 840 | } |
| 841 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 842 | // Fetches two non-cryptographic URL requests via a HTTPS proxy with a QUIC |
| 843 | // alternative proxy. Verifies that if the alternative proxy job returns |
| 844 | // |error_code|, the request is fetched successfully by the main job. |
| 845 | void TestAlternativeProxy(int error_code) { |
| 846 | // Use a non-cryptographic scheme for the request URL since this request |
| 847 | // will be fetched via proxy with QUIC as the alternative service. |
| 848 | request_.url = GURL("http://example.org/"); |
| 849 | // Data for the alternative proxy server job. |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 850 | MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, error_code, 1)}; |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 851 | MockRead quic_reads[] = { |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 852 | MockRead(SYNCHRONOUS, error_code, 0), |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 853 | }; |
| 854 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 855 | SequencedSocketData quic_data(quic_reads, quic_writes); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 856 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 857 | |
| 858 | // Main job succeeds and the alternative job fails. |
| 859 | // Add data for two requests that will be read by the main job. |
| 860 | MockRead http_reads_1[] = { |
| 861 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 862 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 863 | MockRead(ASYNC, OK)}; |
| 864 | |
| 865 | MockRead http_reads_2[] = { |
| 866 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 867 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 868 | MockRead(ASYNC, OK)}; |
| 869 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 870 | StaticSocketDataProvider http_data_1(http_reads_1, base::span<MockWrite>()); |
| 871 | StaticSocketDataProvider http_data_2(http_reads_2, base::span<MockWrite>()); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 872 | socket_factory_.AddSocketDataProvider(&http_data_1); |
| 873 | socket_factory_.AddSocketDataProvider(&http_data_2); |
| 874 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 875 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 876 | |
| 877 | TestProxyDelegate test_proxy_delegate; |
| 878 | // Proxy URL is different from the request URL. |
| 879 | test_proxy_delegate.set_alternative_proxy_server( |
| 880 | ProxyServer::FromPacString("QUIC myproxy.org:443")); |
| 881 | |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 882 | proxy_resolution_service_ = |
| 883 | ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 884 | "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 885 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 886 | |
| 887 | CreateSession(); |
| 888 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_valid()); |
| 889 | |
| 890 | // The first request should be fetched via the HTTPS proxy. |
| 891 | SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); |
| 892 | |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 893 | // Since the main job succeeded only the alternative proxy server should be |
| 894 | // marked as bad. |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 895 | EXPECT_THAT(session_->proxy_resolution_service()->proxy_retry_info(), |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 896 | ElementsAre(Key("quic://myproxy.org:443"))); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 897 | |
| 898 | // Verify that the second request completes successfully, and the |
| 899 | // alternative proxy server job is not started. |
| 900 | SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); |
| 901 | } |
| 902 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 903 | quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 904 | return quic::test::GetNthClientInitiatedBidirectionalStreamId( |
| 905 | version_.transport_version, n); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 906 | } |
| 907 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 908 | quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 909 | return quic::test::GetNthServerInitiatedUnidirectionalStreamId( |
| 910 | version_.transport_version, n); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 911 | } |
| 912 | |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 913 | static void AddCertificate(SSLSocketDataProvider* ssl_data) { |
Ryan Sleevi | 4f83209 | 2017-11-21 23:25:49 | [diff] [blame] | 914 | ssl_data->ssl_info.cert = |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 915 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"); |
Ryan Sleevi | 4f83209 | 2017-11-21 23:25:49 | [diff] [blame] | 916 | ASSERT_TRUE(ssl_data->ssl_info.cert); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 917 | } |
| 918 | |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 919 | const quic::ParsedQuicVersion version_; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 920 | const bool client_headers_include_h2_stream_dependency_; |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 921 | quic::ParsedQuicVersionVector supported_versions_; |
rch | b1c5698 | 2016-09-03 00:06:01 | [diff] [blame] | 922 | QuicFlagSaver flags_; // Save/restore all QUIC flag values. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 923 | quic::MockClock clock_; |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 924 | quic::test::MockRandom random_generator_; |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 925 | QuicTestPacketMaker client_maker_; |
| 926 | QuicTestPacketMaker server_maker_; |
Nick Harper | eb483e1 | 2019-05-14 00:18:09 | [diff] [blame] | 927 | scoped_refptr<TestTaskRunner> quic_task_runner_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 928 | std::unique_ptr<HttpNetworkSession> session_; |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 929 | MockClientSocketFactory socket_factory_; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 930 | ProofVerifyDetailsChromium verify_details_; |
[email protected] | e8ff2684 | 2013-03-22 21:02:05 | [diff] [blame] | 931 | MockCryptoClientStreamFactory crypto_client_stream_factory_; |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 932 | MockHostResolver host_resolver_; |
| 933 | MockCertVerifier cert_verifier_; |
[email protected] | b1c988b | 2013-06-13 06:48:11 | [diff] [blame] | 934 | TransportSecurityState transport_security_state_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 935 | std::unique_ptr<CTVerifier> cert_transparency_verifier_; |
Ryan Sleevi | 8a9c9c1 | 2018-05-09 02:36:23 | [diff] [blame] | 936 | DefaultCTPolicyEnforcer ct_policy_enforcer_; |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 937 | TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_; |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 938 | std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 939 | std::unique_ptr<ProxyResolutionService> proxy_resolution_service_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 940 | std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_; |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 941 | std::unique_ptr<HttpServerProperties> http_server_properties_; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 942 | HttpNetworkSession::Params session_params_; |
| 943 | HttpNetworkSession::Context session_context_; |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 944 | HttpRequestInfo request_; |
vishal.b | 62985ca9 | 2015-04-17 08:45:51 | [diff] [blame] | 945 | BoundTestNetLog net_log_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 946 | std::vector<std::unique_ptr<StaticSocketDataProvider>> hanging_data_; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 947 | SSLSocketDataProvider ssl_data_; |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 948 | std::unique_ptr<ScopedMockNetworkChangeNotifier> scoped_mock_change_notifier_; |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 949 | |
| 950 | private: |
| 951 | void SendRequestAndExpectQuicResponseMaybeFromProxy( |
| 952 | const std::string& expected, |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 953 | bool used_proxy, |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 954 | uint16_t port) { |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 955 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 956 | HeadersHandler headers_handler; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 957 | trans.SetBeforeHeadersSentCallback( |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 958 | base::Bind(&HeadersHandler::OnBeforeHeadersSent, |
| 959 | base::Unretained(&headers_handler))); |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 960 | RunTransaction(&trans); |
| 961 | CheckWasQuicResponse(&trans); |
| 962 | CheckResponsePort(&trans, port); |
| 963 | CheckResponseData(&trans, expected); |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 964 | EXPECT_EQ(used_proxy, headers_handler.was_proxied()); |
tbansal | 2ecbbc7 | 2016-10-06 17:15:47 | [diff] [blame] | 965 | if (used_proxy) { |
| 966 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 967 | } else { |
| 968 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_direct()); |
| 969 | } |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 970 | } |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 971 | }; |
| 972 | |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 973 | quic::ParsedQuicVersionVector AllSupportedVersionsWithoutTls() { |
| 974 | quic::ParsedQuicVersionVector versions; |
Ryan Hamilton | 93424eb8 | 2019-08-23 04:28:40 | [diff] [blame] | 975 | for (auto version : quic::AllSupportedVersions()) { |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 976 | // TODO(rch): crbug.com/978745 - Make this work with TLS |
| 977 | if (version.handshake_protocol != quic::PROTOCOL_TLS1_3) { |
| 978 | versions.push_back(version); |
| 979 | } |
| 980 | } |
| 981 | return versions; |
| 982 | } |
| 983 | |
Victor Costan | e635086f | 2019-01-27 05:20:30 | [diff] [blame] | 984 | INSTANTIATE_TEST_SUITE_P( |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 985 | VersionIncludeStreamDependencySequence, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 986 | QuicNetworkTransactionTest, |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 987 | ::testing::Combine(::testing::ValuesIn(AllSupportedVersionsWithoutTls()), |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 988 | ::testing::Bool())); |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 989 | |
Shivani Sharma | 8ae506c | 2019-07-21 21:08:27 | [diff] [blame] | 990 | // TODO(950069): Add testing for frame_origin in NetworkIsolationKey using |
| 991 | // kAppendInitiatingFrameOriginToNetworkIsolationKey. |
| 992 | |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 993 | TEST_P(QuicNetworkTransactionTest, WriteErrorHandshakeConfirmed) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 994 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 995 | base::HistogramTester histograms; |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 996 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 997 | HostPortPair::FromString("mail.example.org:443")); |
| 998 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 999 | MockCryptoClientStream::CONFIRM_HANDSHAKE); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1000 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1001 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1002 | if (VersionUsesQpack(version_.transport_version)) |
| 1003 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1)); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1004 | mock_quic_data.AddWrite(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED); |
| 1005 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
| 1006 | mock_quic_data.AddRead(ASYNC, OK); // No more data to read |
| 1007 | |
| 1008 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1009 | |
| 1010 | CreateSession(); |
| 1011 | |
| 1012 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 1013 | TestCompletionCallback callback; |
| 1014 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 1015 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1016 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 1017 | |
| 1018 | histograms.ExpectBucketCount("Net.QuicSession.WriteError", |
| 1019 | -ERR_INTERNET_DISCONNECTED, 1); |
| 1020 | histograms.ExpectBucketCount("Net.QuicSession.WriteError.HandshakeConfirmed", |
| 1021 | -ERR_INTERNET_DISCONNECTED, 1); |
| 1022 | } |
| 1023 | |
| 1024 | TEST_P(QuicNetworkTransactionTest, WriteErrorHandshakeConfirmedAsync) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1025 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1026 | base::HistogramTester histograms; |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1027 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1028 | HostPortPair::FromString("mail.example.org:443")); |
| 1029 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1030 | MockCryptoClientStream::CONFIRM_HANDSHAKE); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1031 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1032 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1033 | if (VersionUsesQpack(version_.transport_version)) |
| 1034 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1)); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1035 | mock_quic_data.AddWrite(ASYNC, ERR_INTERNET_DISCONNECTED); |
| 1036 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
| 1037 | mock_quic_data.AddRead(ASYNC, OK); // No more data to read |
| 1038 | |
| 1039 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1040 | |
| 1041 | CreateSession(); |
| 1042 | |
| 1043 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 1044 | TestCompletionCallback callback; |
| 1045 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 1046 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1047 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 1048 | |
| 1049 | histograms.ExpectBucketCount("Net.QuicSession.WriteError", |
| 1050 | -ERR_INTERNET_DISCONNECTED, 1); |
| 1051 | histograms.ExpectBucketCount("Net.QuicSession.WriteError.HandshakeConfirmed", |
| 1052 | -ERR_INTERNET_DISCONNECTED, 1); |
| 1053 | } |
| 1054 | |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1055 | TEST_P(QuicNetworkTransactionTest, SocketWatcherEnabled) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1056 | session_params_.quic_params.origins_to_force_quic_on.insert( |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1057 | HostPortPair::FromString("mail.example.org:443")); |
| 1058 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1059 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1060 | int packet_num = 1; |
| 1061 | if (VersionUsesQpack(version_.transport_version)) { |
| 1062 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1063 | ConstructInitialSettingsPacket(packet_num++)); |
| 1064 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1065 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1066 | SYNCHRONOUS, |
| 1067 | ConstructClientRequestHeadersPacket( |
| 1068 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1069 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1070 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1071 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1072 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1073 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1074 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1075 | mock_quic_data.AddRead( |
| 1076 | ASYNC, ConstructServerDataPacket( |
| 1077 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1078 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1079 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1080 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1081 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 1082 | |
| 1083 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1084 | |
| 1085 | CreateSession(); |
| 1086 | test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(true); |
| 1087 | |
| 1088 | EXPECT_FALSE( |
| 1089 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1090 | SendRequestAndExpectQuicResponse("hello!"); |
| 1091 | EXPECT_TRUE( |
| 1092 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1093 | } |
| 1094 | |
| 1095 | TEST_P(QuicNetworkTransactionTest, SocketWatcherDisabled) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1096 | session_params_.quic_params.origins_to_force_quic_on.insert( |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1097 | HostPortPair::FromString("mail.example.org:443")); |
| 1098 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1099 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1100 | int packet_num = 1; |
| 1101 | if (VersionUsesQpack(version_.transport_version)) { |
| 1102 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1103 | ConstructInitialSettingsPacket(packet_num++)); |
| 1104 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1105 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1106 | SYNCHRONOUS, |
| 1107 | ConstructClientRequestHeadersPacket( |
| 1108 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1109 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1110 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1111 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1112 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1113 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1114 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1115 | mock_quic_data.AddRead( |
| 1116 | ASYNC, ConstructServerDataPacket( |
| 1117 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1118 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1119 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1120 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1121 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 1122 | |
| 1123 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1124 | |
| 1125 | CreateSession(); |
| 1126 | test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(false); |
| 1127 | |
| 1128 | EXPECT_FALSE( |
| 1129 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1130 | SendRequestAndExpectQuicResponse("hello!"); |
| 1131 | EXPECT_FALSE( |
| 1132 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1133 | } |
| 1134 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 1135 | TEST_P(QuicNetworkTransactionTest, ForceQuic) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1136 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 1137 | HostPortPair::FromString("mail.example.org:443")); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1138 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1139 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1140 | int packet_num = 1; |
| 1141 | if (VersionUsesQpack(version_.transport_version)) { |
| 1142 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1143 | ConstructInitialSettingsPacket(packet_num++)); |
| 1144 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1145 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1146 | SYNCHRONOUS, |
| 1147 | ConstructClientRequestHeadersPacket( |
| 1148 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1149 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1150 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1151 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1152 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1153 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1154 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1155 | mock_quic_data.AddRead( |
| 1156 | ASYNC, ConstructServerDataPacket( |
| 1157 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1158 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1159 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1160 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1161 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1162 | |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 1163 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1164 | |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1165 | CreateSession(); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1166 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 1167 | SendRequestAndExpectQuicResponse("hello!"); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1168 | |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1169 | // Check that the NetLog was filled reasonably. |
Eric Roman | 79cc755 | 2019-07-19 02:17:54 | [diff] [blame] | 1170 | auto entries = net_log_.GetEntries(); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1171 | EXPECT_LT(0u, entries.size()); |
| 1172 | |
| 1173 | // Check that we logged a QUIC_SESSION_PACKET_RECEIVED. |
ttuttle | 859dc7a | 2015-04-23 19:42:29 | [diff] [blame] | 1174 | int pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1175 | entries, 0, NetLogEventType::QUIC_SESSION_PACKET_RECEIVED, |
| 1176 | NetLogEventPhase::NONE); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1177 | EXPECT_LT(0, pos); |
| 1178 | |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1179 | // ... and also a TYPE_QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED. |
ttuttle | 859dc7a | 2015-04-23 19:42:29 | [diff] [blame] | 1180 | pos = ExpectLogContainsSomewhere( |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1181 | entries, 0, |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1182 | NetLogEventType::QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED, |
| 1183 | NetLogEventPhase::NONE); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1184 | EXPECT_LT(0, pos); |
| 1185 | |
Eric Roman | 79cc755 | 2019-07-19 02:17:54 | [diff] [blame] | 1186 | EXPECT_EQ(1, GetIntegerValueFromParams(entries[pos], "packet_number")); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1187 | |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1188 | // ... and also a TYPE_QUIC_SESSION_PACKET_AUTHENTICATED. |
| 1189 | pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1190 | entries, 0, NetLogEventType::QUIC_SESSION_PACKET_AUTHENTICATED, |
| 1191 | NetLogEventPhase::NONE); |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1192 | EXPECT_LT(0, pos); |
| 1193 | |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1194 | // ... and also a QUIC_SESSION_STREAM_FRAME_RECEIVED. |
ttuttle | 859dc7a | 2015-04-23 19:42:29 | [diff] [blame] | 1195 | pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1196 | entries, 0, NetLogEventType::QUIC_SESSION_STREAM_FRAME_RECEIVED, |
| 1197 | NetLogEventPhase::NONE); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1198 | EXPECT_LT(0, pos); |
| 1199 | |
Eric Roman | 79cc755 | 2019-07-19 02:17:54 | [diff] [blame] | 1200 | int log_stream_id = GetIntegerValueFromParams(entries[pos], "stream_id"); |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1201 | if (quic::VersionUsesQpack(version_.transport_version)) { |
| 1202 | EXPECT_EQ(GetNthClientInitiatedBidirectionalStreamId(0), |
| 1203 | static_cast<quic::QuicStreamId>(log_stream_id)); |
| 1204 | } else { |
| 1205 | EXPECT_EQ(quic::QuicUtils::GetHeadersStreamId(version_.transport_version), |
| 1206 | static_cast<quic::QuicStreamId>(log_stream_id)); |
| 1207 | } |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1208 | } |
| 1209 | |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1210 | TEST_P(QuicNetworkTransactionTest, LargeResponseHeaders) { |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1211 | // TODO(rch): honor the max header list size. b/136108828 |
| 1212 | if (quic::VersionUsesQpack(version_.transport_version)) |
| 1213 | return; |
| 1214 | |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1215 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1216 | HostPortPair::FromString("mail.example.org:443")); |
| 1217 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1218 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1219 | int packet_num = 1; |
| 1220 | if (VersionUsesQpack(version_.transport_version)) { |
| 1221 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1222 | ConstructInitialSettingsPacket(packet_num++)); |
| 1223 | } |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1224 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1225 | SYNCHRONOUS, |
| 1226 | ConstructClientRequestHeadersPacket( |
| 1227 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1228 | true, GetRequestHeaders("GET", "https", "/"))); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 1229 | spdy::SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK"); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1230 | response_headers["key1"] = std::string(30000, 'A'); |
| 1231 | response_headers["key2"] = std::string(30000, 'A'); |
| 1232 | response_headers["key3"] = std::string(30000, 'A'); |
| 1233 | response_headers["key4"] = std::string(30000, 'A'); |
| 1234 | response_headers["key5"] = std::string(30000, 'A'); |
| 1235 | response_headers["key6"] = std::string(30000, 'A'); |
| 1236 | response_headers["key7"] = std::string(30000, 'A'); |
| 1237 | response_headers["key8"] = std::string(30000, 'A'); |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1238 | quic::QuicStreamId stream_id; |
| 1239 | std::string response_data; |
| 1240 | if (quic::VersionUsesQpack(version_.transport_version)) { |
| 1241 | stream_id = GetNthClientInitiatedBidirectionalStreamId(0); |
| 1242 | std::vector<std::string> encoded = server_maker_.QpackEncodeHeaders( |
| 1243 | stream_id, std::move(response_headers), nullptr); |
| 1244 | for (const auto& e : encoded) { |
| 1245 | response_data += e; |
| 1246 | } |
| 1247 | } else { |
| 1248 | stream_id = quic::QuicUtils::GetHeadersStreamId(version_.transport_version); |
| 1249 | spdy::SpdyHeadersIR headers_frame( |
| 1250 | GetNthClientInitiatedBidirectionalStreamId(0), |
| 1251 | std::move(response_headers)); |
| 1252 | spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION); |
| 1253 | spdy::SpdySerializedFrame spdy_frame = |
| 1254 | response_framer.SerializeFrame(headers_frame); |
| 1255 | response_data = std::string(spdy_frame.data(), spdy_frame.size()); |
| 1256 | } |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1257 | |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 1258 | uint64_t packet_number = 1; |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1259 | size_t chunk_size = 1200; |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1260 | for (size_t offset = 0; offset < response_data.length(); |
| 1261 | offset += chunk_size) { |
| 1262 | size_t len = std::min(chunk_size, response_data.length() - offset); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1263 | mock_quic_data.AddRead( |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1264 | ASYNC, ConstructServerDataPacket( |
| 1265 | packet_number++, stream_id, false, false, |
| 1266 | base::StringPiece(response_data.data() + offset, len))); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1267 | } |
| 1268 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1269 | std::string header = ConstructDataHeader(6); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1270 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1271 | ASYNC, ConstructServerDataPacket( |
| 1272 | packet_number, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1273 | false, true, header + "hello!")); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1274 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1275 | mock_quic_data.AddWrite(ASYNC, |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1276 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
| 1277 | mock_quic_data.AddWrite( |
| 1278 | ASYNC, ConstructClientAckPacket(packet_num++, packet_number, 3, 1)); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1279 | |
| 1280 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1281 | |
| 1282 | CreateSession(); |
| 1283 | |
| 1284 | SendRequestAndExpectQuicResponse("hello!"); |
Zhongyi Shi | 99d0cdd | 2019-05-21 01:18:42 | [diff] [blame] | 1285 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 1286 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1287 | } |
| 1288 | |
| 1289 | TEST_P(QuicNetworkTransactionTest, TooLargeResponseHeaders) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1290 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
| 1291 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1292 | HostPortPair::FromString("mail.example.org:443")); |
| 1293 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1294 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1295 | int packet_num = 1; |
| 1296 | if (VersionUsesQpack(version_.transport_version)) { |
| 1297 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1298 | ConstructInitialSettingsPacket(packet_num++)); |
| 1299 | } |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1300 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1301 | SYNCHRONOUS, |
| 1302 | ConstructClientRequestHeadersPacket( |
| 1303 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1304 | true, GetRequestHeaders("GET", "https", "/"))); |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1305 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 1306 | spdy::SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK"); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1307 | response_headers["key1"] = std::string(30000, 'A'); |
| 1308 | response_headers["key2"] = std::string(30000, 'A'); |
| 1309 | response_headers["key3"] = std::string(30000, 'A'); |
| 1310 | response_headers["key4"] = std::string(30000, 'A'); |
| 1311 | response_headers["key5"] = std::string(30000, 'A'); |
| 1312 | response_headers["key6"] = std::string(30000, 'A'); |
| 1313 | response_headers["key7"] = std::string(30000, 'A'); |
| 1314 | response_headers["key8"] = std::string(30000, 'A'); |
| 1315 | response_headers["key9"] = std::string(30000, 'A'); |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1316 | |
| 1317 | quic::QuicStreamId stream_id; |
| 1318 | std::string response_data; |
| 1319 | if (quic::VersionUsesQpack(version_.transport_version)) { |
| 1320 | stream_id = GetNthClientInitiatedBidirectionalStreamId(0); |
| 1321 | std::vector<std::string> encoded = server_maker_.QpackEncodeHeaders( |
| 1322 | stream_id, std::move(response_headers), nullptr); |
| 1323 | for (const auto& e : encoded) { |
| 1324 | response_data += e; |
| 1325 | } |
| 1326 | } else { |
| 1327 | stream_id = quic::QuicUtils::GetHeadersStreamId(version_.transport_version); |
| 1328 | spdy::SpdyHeadersIR headers_frame( |
| 1329 | GetNthClientInitiatedBidirectionalStreamId(0), |
| 1330 | std::move(response_headers)); |
| 1331 | spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION); |
| 1332 | spdy::SpdySerializedFrame spdy_frame = |
| 1333 | response_framer.SerializeFrame(headers_frame); |
| 1334 | response_data = std::string(spdy_frame.data(), spdy_frame.size()); |
| 1335 | } |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1336 | |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 1337 | uint64_t packet_number = 1; |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1338 | size_t chunk_size = 1200; |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1339 | for (size_t offset = 0; offset < response_data.length(); |
| 1340 | offset += chunk_size) { |
| 1341 | size_t len = std::min(chunk_size, response_data.length() - offset); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1342 | mock_quic_data.AddRead( |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 1343 | ASYNC, ConstructServerDataPacket( |
| 1344 | packet_number++, stream_id, false, false, |
| 1345 | base::StringPiece(response_data.data() + offset, len))); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1346 | } |
| 1347 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1348 | std::string header = ConstructDataHeader(6); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 1349 | |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1350 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1351 | ASYNC, ConstructServerDataPacket( |
| 1352 | packet_number, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1353 | false, true, header + "hello!")); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1354 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1355 | mock_quic_data.AddWrite(ASYNC, |
| 1356 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1357 | mock_quic_data.AddWrite( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1358 | ASYNC, ConstructClientAckAndRstPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1359 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1360 | quic::QUIC_HEADERS_TOO_LARGE, packet_number, 3, 1)); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1361 | |
| 1362 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1363 | |
| 1364 | CreateSession(); |
| 1365 | |
| 1366 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 1367 | TestCompletionCallback callback; |
| 1368 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 1369 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1370 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 1371 | } |
| 1372 | |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1373 | TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1374 | session_params_.quic_params.origins_to_force_quic_on.insert(HostPortPair()); |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1375 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1376 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1377 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1378 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1379 | int packet_num = 1; |
| 1380 | if (VersionUsesQpack(version_.transport_version)) { |
| 1381 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1382 | ConstructInitialSettingsPacket(packet_num++)); |
| 1383 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1384 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1385 | SYNCHRONOUS, |
| 1386 | ConstructClientRequestHeadersPacket( |
| 1387 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1388 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1389 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1390 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1391 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1392 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1393 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1394 | mock_quic_data.AddRead( |
| 1395 | ASYNC, ConstructServerDataPacket( |
| 1396 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1397 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1398 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1399 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1400 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 1401 | |
| 1402 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1403 | |
| 1404 | CreateSession(); |
| 1405 | |
| 1406 | SendRequestAndExpectQuicResponse("hello!"); |
| 1407 | EXPECT_TRUE( |
| 1408 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1409 | } |
| 1410 | |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1411 | TEST_P(QuicNetworkTransactionTest, QuicProxy) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1412 | session_params_.enable_quic = true; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 1413 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 1414 | "QUIC mail.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1415 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1416 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1417 | int packet_num = 1; |
| 1418 | if (VersionUsesQpack(version_.transport_version)) { |
| 1419 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1420 | ConstructInitialSettingsPacket(packet_num++)); |
| 1421 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1422 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1423 | SYNCHRONOUS, |
| 1424 | ConstructClientRequestHeadersPacket( |
| 1425 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1426 | true, GetRequestHeaders("GET", "http", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1427 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1428 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1429 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1430 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1431 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1432 | mock_quic_data.AddRead( |
| 1433 | ASYNC, ConstructServerDataPacket( |
| 1434 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1435 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1436 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1437 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 1438 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1439 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1440 | |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 1441 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1442 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1443 | EXPECT_FALSE( |
| 1444 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1445 | // There is no need to set up an alternate protocol job, because |
| 1446 | // no attempt will be made to speak to the proxy over TCP. |
| 1447 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 1448 | request_.url = GURL("http://mail.example.org/"); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1449 | CreateSession(); |
| 1450 | |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 1451 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1452 | EXPECT_TRUE( |
| 1453 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1454 | } |
| 1455 | |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1456 | // Regression test for https://crbug.com/492458. Test that for an HTTP |
| 1457 | // connection through a QUIC proxy, the certificate exhibited by the proxy is |
| 1458 | // checked against the proxy hostname, not the origin hostname. |
| 1459 | TEST_P(QuicNetworkTransactionTest, QuicProxyWithCert) { |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 1460 | const std::string origin_host = "mail.example.com"; |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1461 | const std::string proxy_host = "www.example.org"; |
| 1462 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1463 | session_params_.enable_quic = true; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 1464 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 1465 | "QUIC " + proxy_host + ":70", TRAFFIC_ANNOTATION_FOR_TESTS); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1466 | |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 1467 | client_maker_.set_hostname(origin_host); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1468 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1469 | int packet_num = 1; |
| 1470 | if (VersionUsesQpack(version_.transport_version)) { |
| 1471 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1472 | ConstructInitialSettingsPacket(packet_num++)); |
| 1473 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1474 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1475 | SYNCHRONOUS, |
| 1476 | ConstructClientRequestHeadersPacket( |
| 1477 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1478 | true, GetRequestHeaders("GET", "http", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1479 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1480 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1481 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1482 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1483 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1484 | mock_quic_data.AddRead( |
| 1485 | ASYNC, ConstructServerDataPacket( |
| 1486 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1487 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1488 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1489 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 1490 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1491 | mock_quic_data.AddRead(ASYNC, 0); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1492 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1493 | |
| 1494 | scoped_refptr<X509Certificate> cert( |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 1495 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1496 | ASSERT_TRUE(cert.get()); |
| 1497 | // This certificate is valid for the proxy, but not for the origin. |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 1498 | EXPECT_TRUE(cert->VerifyNameMatch(proxy_host)); |
| 1499 | EXPECT_FALSE(cert->VerifyNameMatch(origin_host)); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1500 | ProofVerifyDetailsChromium verify_details; |
| 1501 | verify_details.cert_verify_result.verified_cert = cert; |
| 1502 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 1503 | ProofVerifyDetailsChromium verify_details2; |
| 1504 | verify_details2.cert_verify_result.verified_cert = cert; |
| 1505 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1506 | |
| 1507 | request_.url = GURL("http://" + origin_host); |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 1508 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 1509 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1510 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1511 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70); |
| 1512 | } |
| 1513 | |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1514 | TEST_P(QuicNetworkTransactionTest, AlternativeServicesDifferentHost) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1515 | session_params_.quic_params.allow_remote_alt_svc = true; |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1516 | HostPortPair origin("www.example.org", 443); |
| 1517 | HostPortPair alternative("mail.example.org", 443); |
| 1518 | |
| 1519 | base::FilePath certs_dir = GetTestCertsDirectory(); |
| 1520 | scoped_refptr<X509Certificate> cert( |
| 1521 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
| 1522 | ASSERT_TRUE(cert.get()); |
| 1523 | // TODO(rch): the connection should be "to" the origin, so if the cert is |
| 1524 | // valid for the origin but not the alternative, that should work too. |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 1525 | EXPECT_TRUE(cert->VerifyNameMatch(origin.host())); |
| 1526 | EXPECT_TRUE(cert->VerifyNameMatch(alternative.host())); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1527 | ProofVerifyDetailsChromium verify_details; |
| 1528 | verify_details.cert_verify_result.verified_cert = cert; |
| 1529 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 1530 | |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 1531 | client_maker_.set_hostname(origin.host()); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1532 | MockQuicData mock_quic_data(version_); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 1533 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1534 | int packet_num = 1; |
| 1535 | if (VersionUsesQpack(version_.transport_version)) { |
| 1536 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1537 | ConstructInitialSettingsPacket(packet_num++)); |
| 1538 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1539 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1540 | SYNCHRONOUS, |
| 1541 | ConstructClientRequestHeadersPacket( |
| 1542 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1543 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1544 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1545 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1546 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1547 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1548 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1549 | mock_quic_data.AddRead( |
| 1550 | ASYNC, ConstructServerDataPacket( |
| 1551 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1552 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1553 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1554 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1555 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1556 | mock_quic_data.AddRead(ASYNC, 0); |
| 1557 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1558 | |
| 1559 | request_.url = GURL("https://" + origin.host()); |
| 1560 | AddQuicRemoteAlternativeServiceMapping( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1561 | MockCryptoClientStream::CONFIRM_HANDSHAKE, alternative); |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 1562 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 1563 | CreateSession(); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1564 | |
| 1565 | SendRequestAndExpectQuicResponse("hello!"); |
| 1566 | } |
| 1567 | |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1568 | TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 1569 | quic::ParsedQuicVersion unsupported_version = quic::UnsupportedQuicVersion(); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1570 | // Add support for another QUIC version besides |version_|. Also find a |
| 1571 | // unsupported version. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 1572 | for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) { |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1573 | if (version == version_) |
| 1574 | continue; |
| 1575 | if (supported_versions_.size() != 2) { |
| 1576 | supported_versions_.push_back(version); |
| 1577 | continue; |
| 1578 | } |
| 1579 | unsupported_version = version; |
| 1580 | break; |
| 1581 | } |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 1582 | DCHECK_NE(unsupported_version, quic::UnsupportedQuicVersion()); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1583 | |
| 1584 | // Set up alternative service to use QUIC with a version that is not |
| 1585 | // supported. |
| 1586 | url::SchemeHostPort server(request_.url); |
| 1587 | AlternativeService alternative_service(kProtoQUIC, kDefaultServerHostName, |
| 1588 | 443); |
| 1589 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1590 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 1591 | server, NetworkIsolationKey(), alternative_service, expiration, |
| 1592 | {unsupported_version}); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1593 | |
| 1594 | AlternativeServiceInfoVector alt_svc_info_vector = |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1595 | http_server_properties_->GetAlternativeServiceInfos( |
| 1596 | server, NetworkIsolationKey()); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1597 | EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| 1598 | EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| 1599 | EXPECT_EQ(1u, alt_svc_info_vector[0].advertised_versions().size()); |
| 1600 | EXPECT_EQ(unsupported_version, |
| 1601 | alt_svc_info_vector[0].advertised_versions()[0]); |
| 1602 | |
| 1603 | // First request should still be sent via TCP as the QUIC version advertised |
| 1604 | // in the stored AlternativeService is not supported by the client. However, |
| 1605 | // the response from the server will advertise new Alt-Svc with supported |
| 1606 | // versions. |
Ryan Hamilton | 8380c65 | 2019-06-04 02:25:06 | [diff] [blame] | 1607 | quic::ParsedQuicVersionVector versions; |
| 1608 | for (quic::QuicTransportVersion version : |
| 1609 | quic::AllSupportedTransportVersions()) { |
| 1610 | versions.push_back( |
| 1611 | quic::ParsedQuicVersion(quic::PROTOCOL_QUIC_CRYPTO, version)); |
| 1612 | } |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1613 | std::string advertised_versions_list_str = |
Ryan Hamilton | 8380c65 | 2019-06-04 02:25:06 | [diff] [blame] | 1614 | GenerateQuicVersionsListForAltSvcHeader(versions); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1615 | std::string altsvc_header = |
| 1616 | base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n", |
| 1617 | advertised_versions_list_str.c_str()); |
| 1618 | MockRead http_reads[] = { |
| 1619 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 1620 | MockRead("hello world"), |
| 1621 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1622 | MockRead(ASYNC, OK)}; |
| 1623 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1624 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1625 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1626 | AddCertificate(&ssl_data_); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1627 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1628 | |
| 1629 | // Second request should be sent via QUIC as a new list of verions supported |
| 1630 | // by the client has been advertised by the server. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1631 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1632 | int packet_num = 1; |
| 1633 | if (VersionUsesQpack(version_.transport_version)) { |
| 1634 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1635 | ConstructInitialSettingsPacket(packet_num++)); |
| 1636 | } |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1637 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1638 | SYNCHRONOUS, |
| 1639 | ConstructClientRequestHeadersPacket( |
| 1640 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1641 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1642 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1643 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1644 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1645 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1646 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1647 | mock_quic_data.AddRead( |
| 1648 | ASYNC, ConstructServerDataPacket( |
| 1649 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1650 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1651 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1652 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1653 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1654 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 1655 | |
| 1656 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1657 | |
| 1658 | AddHangingNonAlternateProtocolSocketData(); |
| 1659 | |
| 1660 | CreateSession(supported_versions_); |
| 1661 | |
| 1662 | SendRequestAndExpectHttpResponse("hello world"); |
| 1663 | SendRequestAndExpectQuicResponse("hello!"); |
| 1664 | |
| 1665 | // Check alternative service list is updated with new versions. |
| 1666 | alt_svc_info_vector = |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1667 | session_->http_server_properties()->GetAlternativeServiceInfos( |
| 1668 | server, NetworkIsolationKey()); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1669 | EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| 1670 | EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| 1671 | EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size()); |
| 1672 | // Advertised versions will be lised in a sorted order. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 1673 | std::sort( |
| 1674 | supported_versions_.begin(), supported_versions_.end(), |
| 1675 | [](const quic::ParsedQuicVersion& a, const quic::ParsedQuicVersion& b) { |
| 1676 | return a.transport_version < b.transport_version; |
| 1677 | }); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1678 | EXPECT_EQ(supported_versions_[0], |
| 1679 | alt_svc_info_vector[0].advertised_versions()[0]); |
| 1680 | EXPECT_EQ(supported_versions_[1], |
| 1681 | alt_svc_info_vector[0].advertised_versions()[1]); |
| 1682 | } |
| 1683 | |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1684 | // Regression test for https://crbug.com/546991. |
| 1685 | // The server might not be able to serve a request on an alternative connection, |
| 1686 | // and might send a 421 Misdirected Request response status to indicate this. |
| 1687 | // HttpNetworkTransaction should reset the request and retry without using |
| 1688 | // alternative services. |
| 1689 | TEST_P(QuicNetworkTransactionTest, RetryMisdirectedRequest) { |
| 1690 | // Set up alternative service to use QUIC. |
| 1691 | // Note that |origins_to_force_quic_on| cannot be used in this test, because |
| 1692 | // that overrides |enable_alternative_services|. |
| 1693 | url::SchemeHostPort server(request_.url); |
| 1694 | AlternativeService alternative_service(kProtoQUIC, kDefaultServerHostName, |
| 1695 | 443); |
| 1696 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1697 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 1698 | server, NetworkIsolationKey(), alternative_service, expiration, |
| 1699 | supported_versions_); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1700 | |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1701 | // First try: The alternative job uses QUIC and reports an HTTP 421 |
| 1702 | // Misdirected Request error. The main job uses TCP, but |http_data| below is |
| 1703 | // paused at Connect(), so it will never exit the socket pool. This ensures |
| 1704 | // that the alternate job always wins the race and keeps whether the |
| 1705 | // |http_data| exits the socket pool before the main job is aborted |
| 1706 | // deterministic. The first main job gets aborted without the socket pool ever |
| 1707 | // dispensing the socket, making it available for the second try. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1708 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1709 | int packet_num = 1; |
| 1710 | if (VersionUsesQpack(version_.transport_version)) { |
| 1711 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1712 | ConstructInitialSettingsPacket(packet_num++)); |
| 1713 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1714 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1715 | SYNCHRONOUS, |
| 1716 | ConstructClientRequestHeadersPacket( |
| 1717 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1718 | true, GetRequestHeaders("GET", "https", "/"))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1719 | mock_quic_data.AddRead( |
| 1720 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1721 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 1722 | GetResponseHeaders("421"))); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1723 | mock_quic_data.AddRead(ASYNC, OK); |
| 1724 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1725 | |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1726 | // Second try: The main job uses TCP, and there is no alternate job. Once the |
| 1727 | // Connect() is unblocked, |http_data| will leave the socket pool, binding to |
| 1728 | // the main job of the second request. It then succeeds over HTTP/1.1. |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1729 | // Note that if there was an alternative QUIC Job created for the second try, |
| 1730 | // that would read these data, and would fail with ERR_QUIC_PROTOCOL_ERROR. |
| 1731 | // Therefore this test ensures that no alternative Job is created on retry. |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1732 | MockWrite writes[] = {MockWrite(ASYNC, 0, "GET / HTTP/1.1\r\n"), |
| 1733 | MockWrite(ASYNC, 1, "Host: mail.example.org\r\n"), |
| 1734 | MockWrite(ASYNC, 2, "Connection: keep-alive\r\n\r\n")}; |
| 1735 | MockRead reads[] = {MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n\r\n"), |
| 1736 | MockRead(ASYNC, 4, "hello!"), MockRead(ASYNC, OK, 5)}; |
| 1737 | SequencedSocketData http_data(MockConnect(ASYNC, ERR_IO_PENDING) /* pause */, |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1738 | reads, writes); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1739 | socket_factory_.AddSocketDataProvider(&http_data); |
| 1740 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1741 | |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1742 | CreateSession(); |
| 1743 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1744 | |
| 1745 | // Run until |mock_quic_data| has failed and |http_data| has paused. |
| 1746 | TestCompletionCallback callback; |
| 1747 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 1748 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1749 | base::RunLoop().RunUntilIdle(); |
| 1750 | |
| 1751 | // |mock_quic_data| must have run to completion. |
| 1752 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 1753 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 1754 | |
| 1755 | // Now that the QUIC data has been consumed, unblock |http_data|. |
| 1756 | http_data.socket()->OnConnectComplete(MockConnect()); |
| 1757 | |
| 1758 | // The retry logic must hide the 421 status. The transaction succeeds on |
| 1759 | // |http_data|. |
| 1760 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1761 | CheckWasHttpResponse(&trans); |
| 1762 | CheckResponsePort(&trans, 443); |
| 1763 | CheckResponseData(&trans, "hello!"); |
| 1764 | } |
| 1765 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 1766 | TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1767 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 1768 | HostPortPair::FromString("mail.example.org:443")); |
[email protected] | cebe328 | 2013-05-22 23:49:30 | [diff] [blame] | 1769 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1770 | MockQuicData mock_quic_data1(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1771 | if (VersionUsesQpack(version_.transport_version)) |
| 1772 | mock_quic_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1)); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1773 | mock_quic_data1.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 1774 | client_maker_.Reset(); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1775 | MockQuicData mock_quic_data2(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1776 | if (VersionUsesQpack(version_.transport_version)) |
| 1777 | mock_quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 1778 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1779 | mock_quic_data2.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED); |
rch | 6faa4d4 | 2016-01-05 20:48:43 | [diff] [blame] | 1780 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1781 | |
| 1782 | mock_quic_data1.AddSocketDataToFactory(&socket_factory_); |
| 1783 | mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
[email protected] | cebe328 | 2013-05-22 23:49:30 | [diff] [blame] | 1784 | |
| 1785 | CreateSession(); |
| 1786 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1787 | EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count()); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1788 | for (size_t i = 0; i < 2; ++i) { |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 1789 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1790 | TestCompletionCallback callback; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 1791 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 1792 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1793 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED)); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1794 | EXPECT_EQ(1 + i, test_socket_performance_watcher_factory_.watcher_count()); |
Ryan Hamilton | e316e48 | 2017-08-17 02:48:53 | [diff] [blame] | 1795 | |
| 1796 | NetErrorDetails details; |
| 1797 | trans.PopulateNetErrorDetails(&details); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1798 | EXPECT_EQ(quic::QUIC_PACKET_READ_ERROR, details.quic_connection_error); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1799 | } |
[email protected] | cebe328 | 2013-05-22 23:49:30 | [diff] [blame] | 1800 | } |
| 1801 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1802 | TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) { |
| 1803 | // Attempt to "force" quic on 443, which will not be honored. |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 1804 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 1805 | HostPortPair::FromString("www.google.com:443")); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1806 | |
| 1807 | MockRead http_reads[] = { |
| 1808 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"), |
| 1809 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1810 | MockRead(ASYNC, OK)}; |
| 1811 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1812 | StaticSocketDataProvider data(http_reads, base::span<MockWrite>()); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1813 | socket_factory_.AddSocketDataProvider(&data); |
| 1814 | SSLSocketDataProvider ssl(ASYNC, OK); |
| 1815 | socket_factory_.AddSSLSocketDataProvider(&ssl); |
| 1816 | |
| 1817 | CreateSession(); |
| 1818 | |
| 1819 | SendRequestAndExpectHttpResponse("hello world"); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1820 | EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count()); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1821 | } |
| 1822 | |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1823 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuic) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1824 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 1825 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 1826 | MockRead("hello world"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1827 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1828 | MockRead(ASYNC, OK)}; |
| 1829 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1830 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1831 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1832 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 1833 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1834 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 1835 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1836 | int packet_num = 1; |
| 1837 | if (VersionUsesQpack(version_.transport_version)) { |
| 1838 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1839 | ConstructInitialSettingsPacket(packet_num++)); |
| 1840 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1841 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1842 | SYNCHRONOUS, |
| 1843 | ConstructClientRequestHeadersPacket( |
| 1844 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1845 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1846 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1847 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1848 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1849 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 1850 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 1851 | mock_quic_data.AddRead( |
| 1852 | ASYNC, ConstructServerDataPacket( |
| 1853 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 1854 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1855 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1856 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1857 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1858 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1859 | |
| 1860 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1861 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 1862 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 1863 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1864 | |
| 1865 | SendRequestAndExpectHttpResponse("hello world"); |
| 1866 | SendRequestAndExpectQuicResponse("hello!"); |
| 1867 | } |
| 1868 | |
Ryan Hamilton | 64f21d5 | 2019-08-31 07:10:51 | [diff] [blame] | 1869 | TEST_P(QuicNetworkTransactionTest, UseIetfAlternativeServiceForQuic) { |
| 1870 | std::string alt_svc_header = |
| 1871 | "Alt-Svc: " + quic::AlpnForVersion(version_) + "=\":443\"\r\n\r\n"; |
| 1872 | MockRead http_reads[] = { |
| 1873 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(alt_svc_header.data()), |
| 1874 | MockRead("hello world"), |
| 1875 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1876 | MockRead(ASYNC, OK)}; |
| 1877 | |
| 1878 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
| 1879 | socket_factory_.AddSocketDataProvider(&http_data); |
| 1880 | AddCertificate(&ssl_data_); |
| 1881 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1882 | |
| 1883 | MockQuicData mock_quic_data(version_); |
| 1884 | int packet_num = 1; |
| 1885 | if (VersionUsesQpack(version_.transport_version)) { |
| 1886 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1887 | ConstructInitialSettingsPacket(packet_num++)); |
| 1888 | } |
| 1889 | mock_quic_data.AddWrite( |
| 1890 | SYNCHRONOUS, |
| 1891 | ConstructClientRequestHeadersPacket( |
| 1892 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1893 | true, GetRequestHeaders("GET", "https", "/"))); |
| 1894 | mock_quic_data.AddRead( |
| 1895 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1896 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1897 | GetResponseHeaders("200 OK"))); |
| 1898 | std::string header = ConstructDataHeader(6); |
| 1899 | mock_quic_data.AddRead( |
| 1900 | ASYNC, ConstructServerDataPacket( |
| 1901 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 1902 | header + "hello!")); |
| 1903 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1904 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
| 1905 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1906 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 1907 | |
| 1908 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1909 | |
| 1910 | AddHangingNonAlternateProtocolSocketData(); |
| 1911 | CreateSession(); |
| 1912 | |
| 1913 | SendRequestAndExpectHttpResponse("hello world"); |
| 1914 | SendRequestAndExpectQuicResponse("hello!"); |
| 1915 | } |
| 1916 | |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1917 | // Much like above, but makes sure NetworkIsolationKey is respected. |
| 1918 | TEST_P(QuicNetworkTransactionTest, |
| 1919 | UseAlternativeServiceForQuicWithNetworkIsolationKey) { |
| 1920 | base::test::ScopedFeatureList feature_list; |
| 1921 | feature_list.InitAndEnableFeature( |
| 1922 | features::kPartitionHttpServerPropertiesByNetworkIsolationKey); |
| 1923 | // Since HttpServerProperties caches the feature value, have to create a new |
| 1924 | // one. |
| 1925 | http_server_properties_ = std::make_unique<HttpServerProperties>(); |
| 1926 | |
| 1927 | const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/")); |
| 1928 | const net::NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1); |
| 1929 | const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/")); |
| 1930 | const net::NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2); |
| 1931 | |
| 1932 | MockRead http_reads[] = { |
| 1933 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 1934 | MockRead("hello world"), |
| 1935 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1936 | MockRead(ASYNC, OK)}; |
| 1937 | |
| 1938 | AddCertificate(&ssl_data_); |
| 1939 | |
| 1940 | // Request with empty NetworkIsolationKey. |
| 1941 | StaticSocketDataProvider http_data1(http_reads, base::span<MockWrite>()); |
| 1942 | socket_factory_.AddSocketDataProvider(&http_data1); |
| 1943 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1944 | |
| 1945 | // First request with kNetworkIsolationKey1. |
| 1946 | StaticSocketDataProvider http_data2(http_reads, base::span<MockWrite>()); |
| 1947 | socket_factory_.AddSocketDataProvider(&http_data2); |
| 1948 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1949 | |
| 1950 | // Request with kNetworkIsolationKey2. |
| 1951 | StaticSocketDataProvider http_data3(http_reads, base::span<MockWrite>()); |
| 1952 | socket_factory_.AddSocketDataProvider(&http_data3); |
| 1953 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1954 | |
| 1955 | // Second request with kNetworkIsolationKey1, can finally use QUIC, since |
| 1956 | // alternative service infrmation has been received in this context before. |
| 1957 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1958 | int packet_num = 1; |
| 1959 | if (VersionUsesQpack(version_.transport_version)) { |
| 1960 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1961 | ConstructInitialSettingsPacket(packet_num++)); |
| 1962 | } |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1963 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1964 | SYNCHRONOUS, |
| 1965 | ConstructClientRequestHeadersPacket( |
| 1966 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 1967 | true, GetRequestHeaders("GET", "https", "/"))); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1968 | mock_quic_data.AddRead( |
| 1969 | ASYNC, ConstructServerResponseHeadersPacket( |
| 1970 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 1971 | GetResponseHeaders("200 OK"))); |
| 1972 | std::string header = ConstructDataHeader(6); |
| 1973 | mock_quic_data.AddRead( |
| 1974 | ASYNC, ConstructServerDataPacket( |
| 1975 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 1976 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 1977 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 1978 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 1979 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1980 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 1981 | |
| 1982 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1983 | |
| 1984 | AddHangingNonAlternateProtocolSocketData(); |
| 1985 | CreateSession(); |
| 1986 | |
| 1987 | // This is first so that the test fails if alternative service info is |
| 1988 | // written with the right NetworkIsolationKey, but always queried with an |
| 1989 | // empty one. |
| 1990 | request_.network_isolation_key = NetworkIsolationKey(); |
| 1991 | SendRequestAndExpectHttpResponse("hello world"); |
| 1992 | request_.network_isolation_key = kNetworkIsolationKey1; |
| 1993 | SendRequestAndExpectHttpResponse("hello world"); |
| 1994 | request_.network_isolation_key = kNetworkIsolationKey2; |
| 1995 | SendRequestAndExpectHttpResponse("hello world"); |
| 1996 | |
| 1997 | // Only use QUIC when using a NetworkIsolationKey which has been used when |
| 1998 | // alternative service information was received. |
| 1999 | request_.network_isolation_key = kNetworkIsolationKey1; |
| 2000 | SendRequestAndExpectQuicResponse("hello!"); |
| 2001 | } |
| 2002 | |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2003 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic1) { |
| 2004 | // Both server advertises and client supports two QUIC versions. |
| 2005 | // Only |version_| is advertised and supported. |
| 2006 | // The QuicStreamFactoy will pick up |version_|, which is verified as the |
| 2007 | // PacketMakers are using |version_|. |
| 2008 | |
| 2009 | // Add support for another QUIC version besides |version_| on the client side. |
| 2010 | // Also find a different version advertised by the server. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2011 | quic::ParsedQuicVersion advertised_version_2 = quic::UnsupportedQuicVersion(); |
| 2012 | for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) { |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2013 | if (version == version_) |
| 2014 | continue; |
| 2015 | if (supported_versions_.size() != 2) { |
| 2016 | supported_versions_.push_back(version); |
| 2017 | continue; |
| 2018 | } |
| 2019 | advertised_version_2 = version; |
| 2020 | break; |
| 2021 | } |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2022 | DCHECK_NE(advertised_version_2, quic::UnsupportedQuicVersion()); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2023 | |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2024 | std::string QuicAltSvcWithVersionHeader = base::StringPrintf( |
| 2025 | "Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n", |
| 2026 | advertised_version_2.transport_version, version_.transport_version); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2027 | |
| 2028 | MockRead http_reads[] = { |
| 2029 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 2030 | MockRead(QuicAltSvcWithVersionHeader.c_str()), MockRead("hello world"), |
| 2031 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2032 | MockRead(ASYNC, OK)}; |
| 2033 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2034 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2035 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2036 | AddCertificate(&ssl_data_); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2037 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2038 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2039 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2040 | int packet_num = 1; |
| 2041 | if (VersionUsesQpack(version_.transport_version)) { |
| 2042 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2043 | ConstructInitialSettingsPacket(packet_num++)); |
| 2044 | } |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2045 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2046 | SYNCHRONOUS, |
| 2047 | ConstructClientRequestHeadersPacket( |
| 2048 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 2049 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2050 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2051 | ASYNC, ConstructServerResponseHeadersPacket( |
| 2052 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 2053 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 2054 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2055 | mock_quic_data.AddRead( |
| 2056 | ASYNC, ConstructServerDataPacket( |
| 2057 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 2058 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2059 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2060 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2061 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 2062 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 2063 | |
| 2064 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2065 | |
| 2066 | AddHangingNonAlternateProtocolSocketData(); |
| 2067 | CreateSession(supported_versions_); |
| 2068 | |
| 2069 | SendRequestAndExpectHttpResponse("hello world"); |
| 2070 | SendRequestAndExpectQuicResponse("hello!"); |
| 2071 | } |
| 2072 | |
| 2073 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic2) { |
| 2074 | // Client and server mutually support more than one QUIC_VERSION. |
| 2075 | // The QuicStreamFactoy will pick the preferred QUIC_VERSION: |version_|, |
| 2076 | // which is verified as the PacketMakers are using |version_|. |
| 2077 | |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2078 | quic::ParsedQuicVersion common_version_2 = quic::UnsupportedQuicVersion(); |
| 2079 | for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) { |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2080 | if (version == version_) |
| 2081 | continue; |
| 2082 | common_version_2 = version; |
| 2083 | break; |
| 2084 | } |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2085 | DCHECK_NE(common_version_2, quic::UnsupportedQuicVersion()); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2086 | |
| 2087 | supported_versions_.push_back( |
| 2088 | common_version_2); // Supported but unpreferred. |
| 2089 | |
| 2090 | std::string QuicAltSvcWithVersionHeader = base::StringPrintf( |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2091 | "Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n", |
| 2092 | common_version_2.transport_version, version_.transport_version); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2093 | |
| 2094 | MockRead http_reads[] = { |
| 2095 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 2096 | MockRead(QuicAltSvcWithVersionHeader.c_str()), MockRead("hello world"), |
| 2097 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2098 | MockRead(ASYNC, OK)}; |
| 2099 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2100 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2101 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2102 | AddCertificate(&ssl_data_); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2103 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2104 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2105 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2106 | int packet_num = 1; |
| 2107 | if (VersionUsesQpack(version_.transport_version)) { |
| 2108 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2109 | ConstructInitialSettingsPacket(packet_num++)); |
| 2110 | } |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2111 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2112 | SYNCHRONOUS, |
| 2113 | ConstructClientRequestHeadersPacket( |
| 2114 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 2115 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2116 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2117 | ASYNC, ConstructServerResponseHeadersPacket( |
| 2118 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 2119 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 2120 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2121 | mock_quic_data.AddRead( |
| 2122 | ASYNC, ConstructServerDataPacket( |
| 2123 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 2124 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2125 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2126 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 2127 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 2128 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 2129 | |
| 2130 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2131 | |
| 2132 | AddHangingNonAlternateProtocolSocketData(); |
| 2133 | CreateSession(supported_versions_); |
| 2134 | |
| 2135 | SendRequestAndExpectHttpResponse("hello world"); |
| 2136 | SendRequestAndExpectQuicResponse("hello!"); |
| 2137 | } |
| 2138 | |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 2139 | TEST_P(QuicNetworkTransactionTest, |
| 2140 | UseAlternativeServiceWithProbabilityForQuic) { |
| 2141 | MockRead http_reads[] = { |
| 2142 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 2143 | MockRead(kQuicAlternativeServiceWithProbabilityHeader), |
| 2144 | MockRead("hello world"), |
| 2145 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2146 | MockRead(ASYNC, OK)}; |
| 2147 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2148 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 2149 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2150 | AddCertificate(&ssl_data_); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 2151 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2152 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2153 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2154 | int packet_num = 1; |
| 2155 | if (VersionUsesQpack(version_.transport_version)) { |
| 2156 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2157 | ConstructInitialSettingsPacket(packet_num++)); |
| 2158 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 2159 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2160 | SYNCHRONOUS, |
| 2161 | ConstructClientRequestHeadersPacket( |
| 2162 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 2163 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2164 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2165 | ASYNC, ConstructServerResponseHeadersPacket( |
| 2166 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 2167 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 2168 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2169 | mock_quic_data.AddRead( |
| 2170 | ASYNC, ConstructServerDataPacket( |
| 2171 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 2172 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2173 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2174 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 2175 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 2176 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 2177 | |
| 2178 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2179 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 2180 | AddHangingNonAlternateProtocolSocketData(); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 2181 | CreateSession(); |
| 2182 | |
| 2183 | SendRequestAndExpectHttpResponse("hello world"); |
| 2184 | SendRequestAndExpectQuicResponse("hello!"); |
| 2185 | } |
| 2186 | |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2187 | TEST_P(QuicNetworkTransactionTest, SetAlternativeServiceWithScheme) { |
| 2188 | MockRead http_reads[] = { |
| 2189 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 2190 | MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
| 2191 | MockRead("hello world"), |
| 2192 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2193 | MockRead(ASYNC, OK)}; |
| 2194 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2195 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2196 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2197 | AddCertificate(&ssl_data_); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2198 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2199 | |
| 2200 | CreateSession(); |
bnc | b2602438 | 2016-06-29 02:39:45 | [diff] [blame] | 2201 | // Send https request, ignore alternative service advertising if response |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2202 | // header advertises alternative service for mail.example.org. |
bnc | b2602438 | 2016-06-29 02:39:45 | [diff] [blame] | 2203 | request_.url = GURL("https://mail.example.org:443"); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2204 | SendRequestAndExpectHttpResponse("hello world"); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 2205 | HttpServerProperties* http_server_properties = |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2206 | session_->http_server_properties(); |
| 2207 | url::SchemeHostPort http_server("http", "mail.example.org", 443); |
| 2208 | url::SchemeHostPort https_server("https", "mail.example.org", 443); |
| 2209 | // Check alternative service is set for the correct origin. |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2210 | EXPECT_EQ( |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 2211 | 2u, http_server_properties |
| 2212 | ->GetAlternativeServiceInfos(https_server, NetworkIsolationKey()) |
| 2213 | .size()); |
bnc | b2602438 | 2016-06-29 02:39:45 | [diff] [blame] | 2214 | EXPECT_TRUE( |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 2215 | http_server_properties |
| 2216 | ->GetAlternativeServiceInfos(http_server, NetworkIsolationKey()) |
| 2217 | .empty()); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2218 | } |
| 2219 | |
| 2220 | TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) { |
| 2221 | MockRead http_reads[] = { |
| 2222 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 2223 | MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
| 2224 | MockRead("hello world"), |
| 2225 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2226 | MockRead(ASYNC, OK)}; |
| 2227 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2228 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2229 | AddCertificate(&ssl_data_); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2230 | |
| 2231 | socket_factory_.AddSocketDataProvider(&http_data); |
| 2232 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2233 | socket_factory_.AddSocketDataProvider(&http_data); |
| 2234 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2235 | |
| 2236 | CreateSession(); |
| 2237 | |
| 2238 | // Send https request and set alternative services if response header |
| 2239 | // advertises alternative service for mail.example.org. |
| 2240 | SendRequestAndExpectHttpResponse("hello world"); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 2241 | HttpServerProperties* http_server_properties = |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2242 | session_->http_server_properties(); |
| 2243 | |
| 2244 | const url::SchemeHostPort https_server(request_.url); |
| 2245 | // Check alternative service is set. |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 2246 | EXPECT_EQ( |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 2247 | 2u, http_server_properties |
| 2248 | ->GetAlternativeServiceInfos(https_server, NetworkIsolationKey()) |
| 2249 | .size()); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 2250 | |
| 2251 | // Send http request to the same origin but with diffrent scheme, should not |
| 2252 | // use QUIC. |
| 2253 | request_.url = GURL("http://mail.example.org:443"); |
| 2254 | SendRequestAndExpectHttpResponse("hello world"); |
| 2255 | } |
| 2256 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2257 | TEST_P(QuicNetworkTransactionTest, |
| 2258 | StoreMutuallySupportedVersionsWhenProcessAltSvc) { |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2259 | // Add support for another QUIC version besides |version_|. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2260 | for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) { |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2261 | if (version == version_) |
| 2262 | continue; |
| 2263 | supported_versions_.push_back(version); |
| 2264 | break; |
| 2265 | } |
| 2266 | |
Ryan Hamilton | 8380c65 | 2019-06-04 02:25:06 | [diff] [blame] | 2267 | quic::ParsedQuicVersionVector versions; |
| 2268 | for (quic::QuicTransportVersion version : |
| 2269 | quic::AllSupportedTransportVersions()) { |
| 2270 | versions.push_back( |
| 2271 | quic::ParsedQuicVersion(quic::PROTOCOL_QUIC_CRYPTO, version)); |
| 2272 | } |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2273 | std::string advertised_versions_list_str = |
Ryan Hamilton | 8380c65 | 2019-06-04 02:25:06 | [diff] [blame] | 2274 | GenerateQuicVersionsListForAltSvcHeader(versions); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2275 | std::string altsvc_header = |
| 2276 | base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n", |
| 2277 | advertised_versions_list_str.c_str()); |
| 2278 | MockRead http_reads[] = { |
| 2279 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 2280 | MockRead("hello world"), |
| 2281 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2282 | MockRead(ASYNC, OK)}; |
| 2283 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2284 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2285 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2286 | AddCertificate(&ssl_data_); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2287 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2288 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2289 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2290 | int packet_num = 1; |
| 2291 | if (VersionUsesQpack(version_.transport_version)) { |
| 2292 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2293 | ConstructInitialSettingsPacket(packet_num++)); |
| 2294 | } |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2295 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2296 | SYNCHRONOUS, |
| 2297 | ConstructClientRequestHeadersPacket( |
| 2298 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 2299 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2300 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2301 | ASYNC, ConstructServerResponseHeadersPacket( |
| 2302 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 2303 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 2304 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2305 | mock_quic_data.AddRead( |
| 2306 | ASYNC, ConstructServerDataPacket( |
| 2307 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 2308 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2309 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2310 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2311 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 2312 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 2313 | |
| 2314 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2315 | |
| 2316 | AddHangingNonAlternateProtocolSocketData(); |
| 2317 | |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2318 | CreateSession(supported_versions_); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2319 | |
| 2320 | SendRequestAndExpectHttpResponse("hello world"); |
| 2321 | SendRequestAndExpectQuicResponse("hello!"); |
| 2322 | |
| 2323 | // Check alternative service is set with only mutually supported versions. |
| 2324 | const url::SchemeHostPort https_server(request_.url); |
| 2325 | const AlternativeServiceInfoVector alt_svc_info_vector = |
| 2326 | session_->http_server_properties()->GetAlternativeServiceInfos( |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 2327 | https_server, NetworkIsolationKey()); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2328 | EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| 2329 | EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| 2330 | EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size()); |
| 2331 | // Advertised versions will be lised in a sorted order. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2332 | std::sort( |
| 2333 | supported_versions_.begin(), supported_versions_.end(), |
| 2334 | [](const quic::ParsedQuicVersion& a, const quic::ParsedQuicVersion& b) { |
| 2335 | return a.transport_version < b.transport_version; |
| 2336 | }); |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2337 | EXPECT_EQ(supported_versions_[0], |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2338 | alt_svc_info_vector[0].advertised_versions()[0]); |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2339 | EXPECT_EQ(supported_versions_[1], |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2340 | alt_svc_info_vector[0].advertised_versions()[1]); |
| 2341 | } |
| 2342 | |
danzh | 3134c256 | 2016-08-12 14:07:52 | [diff] [blame] | 2343 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceAllSupportedVersion) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2344 | std::string altsvc_header = base::StringPrintf( |
| 2345 | "Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_.transport_version); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2346 | MockRead http_reads[] = { |
| 2347 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 2348 | MockRead("hello world"), |
| 2349 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2350 | MockRead(ASYNC, OK)}; |
| 2351 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2352 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2353 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2354 | AddCertificate(&ssl_data_); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2355 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2356 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2357 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2358 | int packet_num = 1; |
| 2359 | if (VersionUsesQpack(version_.transport_version)) { |
| 2360 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2361 | ConstructInitialSettingsPacket(packet_num++)); |
| 2362 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 2363 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2364 | SYNCHRONOUS, |
| 2365 | ConstructClientRequestHeadersPacket( |
| 2366 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 2367 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2368 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2369 | ASYNC, ConstructServerResponseHeadersPacket( |
| 2370 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 2371 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 2372 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2373 | mock_quic_data.AddRead( |
| 2374 | ASYNC, ConstructServerDataPacket( |
| 2375 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 2376 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2377 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2378 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2379 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 2380 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2381 | |
| 2382 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2383 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 2384 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 2385 | CreateSession(); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2386 | |
| 2387 | SendRequestAndExpectHttpResponse("hello world"); |
| 2388 | SendRequestAndExpectQuicResponse("hello!"); |
| 2389 | } |
| 2390 | |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2391 | TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2392 | if (version_.transport_version == quic::QUIC_VERSION_99) { |
Frank Kastenholz | 6e4c538 | 2018-06-21 23:00:09 | [diff] [blame] | 2393 | // Not available under version 99 |
| 2394 | return; |
| 2395 | } |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2396 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2397 | int packet_num = 1; |
| 2398 | if (VersionUsesQpack(version_.transport_version)) { |
| 2399 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2400 | ConstructInitialSettingsPacket(packet_num++)); |
| 2401 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 2402 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2403 | SYNCHRONOUS, |
| 2404 | ConstructClientRequestHeadersPacket( |
| 2405 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 2406 | true, GetRequestHeaders("GET", "https", "/"))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2407 | mock_quic_data.AddRead( |
| 2408 | ASYNC, ConstructServerResponseHeadersPacket( |
| 2409 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 2410 | GetResponseHeaders("200 OK"))); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2411 | // Read a GoAway packet with |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2412 | // quic::QuicErrorCode: quic::QUIC_ERROR_MIGRATING_PORT from the peer. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2413 | mock_quic_data.AddRead(SYNCHRONOUS, |
| 2414 | ConstructServerGoAwayPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2415 | 2, quic::QUIC_ERROR_MIGRATING_PORT, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2416 | "connection migration with port change only")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2417 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 2418 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 2419 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2420 | mock_quic_data.AddRead( |
| 2421 | SYNCHRONOUS, ConstructServerDataPacket( |
| 2422 | 3, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 2423 | true, header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2424 | mock_quic_data.AddWrite( |
| 2425 | SYNCHRONOUS, |
| 2426 | ConstructClientAckAndRstPacket( |
| 2427 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 2428 | quic::QUIC_STREAM_CANCELLED, 3, 3, 1)); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2429 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 2430 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 2431 | |
| 2432 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2433 | |
| 2434 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 2435 | // the alternate-protocol job will "win". |
| 2436 | AddHangingNonAlternateProtocolSocketData(); |
| 2437 | |
| 2438 | // In order for a new QUIC session to be established via alternate-protocol |
| 2439 | // without racing an HTTP connection, we need the host resolution to happen |
| 2440 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2441 | // connection to the the server, in this test we require confirmation |
| 2442 | // before encrypting so the HTTP job will still start. |
| 2443 | host_resolver_.set_synchronous_mode(true); |
| 2444 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2445 | ""); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2446 | |
| 2447 | CreateSession(); |
| 2448 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2449 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2450 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 2451 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2452 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 2453 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 2454 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2455 | |
| 2456 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2457 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 2458 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2459 | |
| 2460 | // Check whether this transaction is correctly marked as received a go-away |
| 2461 | // because of migrating port. |
| 2462 | NetErrorDetails details; |
| 2463 | EXPECT_FALSE(details.quic_port_migration_detected); |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 2464 | trans.PopulateNetErrorDetails(&details); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2465 | EXPECT_TRUE(details.quic_port_migration_detected); |
| 2466 | } |
| 2467 | |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2468 | // This test verifies that a new QUIC connection will be attempted on the |
| 2469 | // alternate network if the original QUIC connection fails with idle timeout |
| 2470 | // before handshake is confirmed. If TCP succeeds and QUIC fails on the |
| 2471 | // alternate network as well, QUIC is marked as broken and the brokenness will |
| 2472 | // not expire when default network changes. |
| 2473 | TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) { |
| 2474 | SetUpTestForRetryConnectionOnAlternateNetwork(); |
| 2475 | |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 2476 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2477 | |
| 2478 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2479 | MockQuicData quic_data(version_); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2480 | quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| 2481 | int packet_num = 1; |
| 2482 | quic_data.AddWrite(SYNCHRONOUS, |
| 2483 | client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| 2484 | // Retranmit the handshake messages. |
| 2485 | quic_data.AddWrite(SYNCHRONOUS, |
| 2486 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2487 | quic_data.AddWrite(SYNCHRONOUS, |
| 2488 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2489 | quic_data.AddWrite(SYNCHRONOUS, |
| 2490 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2491 | quic_data.AddWrite(SYNCHRONOUS, |
| 2492 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2493 | // TODO(zhongyi): remove condition check once b/115926584 is fixed. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2494 | if (version_.transport_version <= quic::QUIC_VERSION_39) { |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2495 | quic_data.AddWrite(SYNCHRONOUS, |
| 2496 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2497 | } |
| 2498 | // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| 2499 | quic_data.AddWrite(SYNCHRONOUS, |
| 2500 | client_maker_.MakeConnectionClosePacket( |
| 2501 | packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 2502 | "No recent network activity.")); |
| 2503 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2504 | |
| 2505 | // Add successful TCP data so that TCP job will succeed. |
| 2506 | MockWrite http_writes[] = { |
| 2507 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 2508 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 2509 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 2510 | |
| 2511 | MockRead http_reads[] = { |
| 2512 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 2513 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 2514 | MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)}; |
| 2515 | SequencedSocketData http_data(http_reads, http_writes); |
| 2516 | socket_factory_.AddSocketDataProvider(&http_data); |
| 2517 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2518 | |
| 2519 | // Add data for the second QUIC connection to fail. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2520 | MockQuicData quic_data2(version_); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2521 | quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 2522 | quic_data2.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); // Write error. |
| 2523 | quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 2524 | |
| 2525 | // Resolve the host resolution synchronously. |
| 2526 | host_resolver_.set_synchronous_mode(true); |
| 2527 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2528 | ""); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2529 | |
| 2530 | CreateSession(); |
| 2531 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 2532 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2533 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2534 | session_->quic_stream_factory(), |
| 2535 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 2536 | &clock_)); |
| 2537 | // Add alternate protocol mapping to race QUIC and TCP. |
| 2538 | // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| 2539 | // peer. |
| 2540 | AddQuicAlternateProtocolMapping( |
| 2541 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| 2542 | |
| 2543 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2544 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 2545 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2546 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2547 | |
| 2548 | // Pump the message loop to get the request started. |
| 2549 | // Request will be served with TCP job. |
| 2550 | base::RunLoop().RunUntilIdle(); |
| 2551 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 2552 | CheckResponseData(&trans, "TCP succeeds"); |
| 2553 | |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2554 | // Fast forward to idle timeout the original connection. A new connection will |
| 2555 | // be kicked off on the alternate network. |
| 2556 | quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| 2557 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 2558 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2559 | |
| 2560 | // Run the message loop to execute posted tasks, which will report job status. |
| 2561 | base::RunLoop().RunUntilIdle(); |
| 2562 | |
| 2563 | // Verify that QUIC is marked as broken. |
| 2564 | ExpectBrokenAlternateProtocolMapping(); |
| 2565 | |
| 2566 | // Deliver a message to notify the new network becomes default, the brokenness |
| 2567 | // will not expire as QUIC is broken on both networks. |
| 2568 | scoped_mock_change_notifier_->mock_network_change_notifier() |
| 2569 | ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| 2570 | ExpectBrokenAlternateProtocolMapping(); |
| 2571 | |
| 2572 | ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| 2573 | ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| 2574 | } |
| 2575 | |
| 2576 | // This test verifies that a new QUIC connection will be attempted on the |
| 2577 | // alternate network if the original QUIC connection fails with idle timeout |
| 2578 | // before handshake is confirmed. If TCP succeeds and QUIC succeeds on the |
| 2579 | // alternate network, QUIC is marked as broken. The brokenness will expire when |
| 2580 | // the default network changes. |
| 2581 | TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) { |
| 2582 | SetUpTestForRetryConnectionOnAlternateNetwork(); |
| 2583 | |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 2584 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2585 | |
| 2586 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2587 | MockQuicData quic_data(version_); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2588 | quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| 2589 | int packet_num = 1; |
| 2590 | quic_data.AddWrite(SYNCHRONOUS, |
| 2591 | client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| 2592 | // Retranmit the handshake messages. |
| 2593 | quic_data.AddWrite(SYNCHRONOUS, |
| 2594 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2595 | quic_data.AddWrite(SYNCHRONOUS, |
| 2596 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2597 | quic_data.AddWrite(SYNCHRONOUS, |
| 2598 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2599 | quic_data.AddWrite(SYNCHRONOUS, |
| 2600 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2601 | // TODO(zhongyi): remove condition check once b/115926584 is fixed. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2602 | if (version_.transport_version <= quic::QUIC_VERSION_39) { |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2603 | quic_data.AddWrite(SYNCHRONOUS, |
| 2604 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2605 | } |
| 2606 | // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| 2607 | quic_data.AddWrite(SYNCHRONOUS, |
| 2608 | client_maker_.MakeConnectionClosePacket( |
| 2609 | packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 2610 | "No recent network activity.")); |
| 2611 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2612 | |
| 2613 | // Add successful TCP data so that TCP job will succeed. |
| 2614 | MockWrite http_writes[] = { |
| 2615 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 2616 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 2617 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 2618 | |
| 2619 | MockRead http_reads[] = { |
| 2620 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 2621 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 2622 | MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)}; |
| 2623 | SequencedSocketData http_data(http_reads, http_writes); |
| 2624 | socket_factory_.AddSocketDataProvider(&http_data); |
| 2625 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2626 | |
| 2627 | // Quic connection will be retried on the alternate network after the initial |
| 2628 | // one fails on the default network. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2629 | MockQuicData quic_data2(version_); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2630 | quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Handing read. |
| 2631 | quic_data2.AddWrite(SYNCHRONOUS, |
| 2632 | client_maker_.MakeDummyCHLOPacket(1)); // CHLO |
| 2633 | |
| 2634 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2635 | if (VersionUsesQpack(version_.transport_version)) |
| 2636 | quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(2)); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2637 | quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 2638 | |
| 2639 | // Resolve the host resolution synchronously. |
| 2640 | host_resolver_.set_synchronous_mode(true); |
| 2641 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2642 | ""); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2643 | |
| 2644 | CreateSession(); |
| 2645 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 2646 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2647 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2648 | session_->quic_stream_factory(), |
| 2649 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 2650 | &clock_)); |
| 2651 | // Add alternate protocol mapping to race QUIC and TCP. |
| 2652 | // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| 2653 | // peer. |
| 2654 | AddQuicAlternateProtocolMapping( |
| 2655 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| 2656 | |
| 2657 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2658 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 2659 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2660 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2661 | |
| 2662 | // Pump the message loop to get the request started. |
| 2663 | // Request will be served with TCP job. |
| 2664 | base::RunLoop().RunUntilIdle(); |
| 2665 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 2666 | CheckResponseData(&trans, "TCP succeeds"); |
| 2667 | |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2668 | // Fast forward to idle timeout the original connection. A new connection will |
| 2669 | // be kicked off on the alternate network. |
| 2670 | quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| 2671 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 2672 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2673 | |
| 2674 | // The second connection hasn't finish handshake, verify that QUIC is not |
| 2675 | // marked as broken. |
| 2676 | ExpectQuicAlternateProtocolMapping(); |
| 2677 | // Explicitly confirm the handshake on the second connection. |
| 2678 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 2679 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 2680 | // Run message loop to execute posted tasks, which will notify JoController |
| 2681 | // about the orphaned job status. |
| 2682 | base::RunLoop().RunUntilIdle(); |
| 2683 | |
| 2684 | // Verify that QUIC is marked as broken. |
| 2685 | ExpectBrokenAlternateProtocolMapping(); |
| 2686 | |
| 2687 | // Deliver a message to notify the new network becomes default, the previous |
| 2688 | // brokenness will be clear as the brokenness is bond with old default |
| 2689 | // network. |
| 2690 | scoped_mock_change_notifier_->mock_network_change_notifier() |
| 2691 | ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| 2692 | ExpectQuicAlternateProtocolMapping(); |
| 2693 | |
| 2694 | ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| 2695 | ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| 2696 | } |
| 2697 | |
| 2698 | // This test verifies that a new QUIC connection will be attempted on the |
| 2699 | // alternate network if the original QUIC connection fails with idle timeout |
| 2700 | // before handshake is confirmed. If TCP doesn't succeed but QUIC on the |
| 2701 | // alternative network succeeds, QUIC is not marked as broken. |
| 2702 | TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPHanging) { |
| 2703 | SetUpTestForRetryConnectionOnAlternateNetwork(); |
| 2704 | |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 2705 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2706 | |
| 2707 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2708 | MockQuicData quic_data(version_); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2709 | quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| 2710 | int packet_num = 1; |
| 2711 | quic_data.AddWrite(SYNCHRONOUS, |
| 2712 | client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| 2713 | // Retranmit the handshake messages. |
| 2714 | quic_data.AddWrite(SYNCHRONOUS, |
| 2715 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2716 | quic_data.AddWrite(SYNCHRONOUS, |
| 2717 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2718 | quic_data.AddWrite(SYNCHRONOUS, |
| 2719 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2720 | quic_data.AddWrite(SYNCHRONOUS, |
| 2721 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2722 | // TODO(zhongyi): remove condition check once b/115926584 is fixed, i.e., |
| 2723 | // quic_fix_has_pending_crypto_data is introduced and enabled. |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 2724 | if (version_.transport_version <= quic::QUIC_VERSION_39) { |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2725 | quic_data.AddWrite(SYNCHRONOUS, |
| 2726 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2727 | } |
| 2728 | // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| 2729 | quic_data.AddWrite(SYNCHRONOUS, |
| 2730 | client_maker_.MakeConnectionClosePacket( |
| 2731 | packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 2732 | "No recent network activity.")); |
| 2733 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2734 | |
| 2735 | // Add hanging TCP data so that TCP job will never succeeded. |
| 2736 | AddHangingNonAlternateProtocolSocketData(); |
| 2737 | |
| 2738 | // Quic connection will then be retried on the alternate network. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2739 | MockQuicData quic_data2(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2740 | packet_num = 1; |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2741 | quic_data2.AddWrite(SYNCHRONOUS, |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2742 | client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2743 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 2744 | const std::string body = "hello!"; |
| 2745 | std::string header = ConstructDataHeader(body.length()); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 2746 | |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2747 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2748 | if (VersionUsesQpack(version_.transport_version)) { |
| 2749 | quic_data2.AddWrite(SYNCHRONOUS, |
| 2750 | ConstructInitialSettingsPacket(packet_num++)); |
| 2751 | } |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2752 | quic_data2.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2753 | SYNCHRONOUS, |
| 2754 | ConstructClientRequestHeadersPacket( |
| 2755 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 2756 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2757 | quic_data2.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 2758 | ASYNC, ConstructServerResponseHeadersPacket( |
| 2759 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 2760 | GetResponseHeaders("200 OK"))); |
| 2761 | quic_data2.AddRead( |
| 2762 | ASYNC, ConstructServerDataPacket( |
| 2763 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 2764 | header + body)); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2765 | quic_data2.AddWrite(SYNCHRONOUS, |
| 2766 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2767 | quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 2768 | quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 2769 | |
| 2770 | // Resolve the host resolution synchronously. |
| 2771 | host_resolver_.set_synchronous_mode(true); |
| 2772 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2773 | ""); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2774 | |
| 2775 | CreateSession(); |
| 2776 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 2777 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2778 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2779 | session_->quic_stream_factory(), |
| 2780 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 2781 | &clock_)); |
| 2782 | // Add alternate protocol mapping to race QUIC and TCP. |
| 2783 | // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| 2784 | // peer. |
| 2785 | AddQuicAlternateProtocolMapping( |
| 2786 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| 2787 | |
| 2788 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2789 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 2790 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2791 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2792 | |
| 2793 | // Pump the message loop to get the request started. |
| 2794 | base::RunLoop().RunUntilIdle(); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2795 | |
| 2796 | // Fast forward to idle timeout the original connection. A new connection will |
| 2797 | // be kicked off on the alternate network. |
| 2798 | quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| 2799 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 2800 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2801 | |
| 2802 | // Verify that QUIC is not marked as broken. |
| 2803 | ExpectQuicAlternateProtocolMapping(); |
| 2804 | // Explicitly confirm the handshake on the second connection. |
| 2805 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 2806 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 2807 | |
| 2808 | // Read the response. |
| 2809 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 2810 | CheckResponseData(&trans, body); |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2811 | // Verify that QUIC is not marked as broken. |
| 2812 | ExpectQuicAlternateProtocolMapping(); |
| 2813 | |
| 2814 | // Deliver a message to notify the new network becomes default. |
| 2815 | scoped_mock_change_notifier_->mock_network_change_notifier() |
| 2816 | ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| 2817 | ExpectQuicAlternateProtocolMapping(); |
| 2818 | ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| 2819 | ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| 2820 | } |
| 2821 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2822 | // Verify that if a QUIC connection times out, the QuicHttpStream will |
| 2823 | // return QUIC_PROTOCOL_ERROR. |
| 2824 | TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 2825 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
Ryan Sleevi | 2e8255b | 2019-07-17 21:02:21 | [diff] [blame] | 2826 | session_params_.quic_params.idle_connection_timeout = |
| 2827 | base::TimeDelta::FromSeconds(5); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2828 | |
| 2829 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2830 | MockQuicData quic_data(version_); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 2831 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2832 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 2833 | |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 2834 | client_maker_.set_save_packet_frames(true); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 2835 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 2836 | quic_data.AddWrite( |
| 2837 | SYNCHRONOUS, |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 2838 | client_maker_.MakeRequestHeadersPacket( |
| 2839 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| 2840 | priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr)); |
| 2841 | |
| 2842 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2843 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2844 | // TLP 1 |
| 2845 | quic_data.AddWrite(SYNCHRONOUS, |
| 2846 | client_maker_.MakeRetransmissionPacket(1, 2, true)); |
| 2847 | // TLP 2 |
| 2848 | quic_data.AddWrite(SYNCHRONOUS, |
| 2849 | client_maker_.MakeRetransmissionPacket(1, 3, true)); |
| 2850 | // RTO 1 |
| 2851 | quic_data.AddWrite(SYNCHRONOUS, |
| 2852 | client_maker_.MakeRetransmissionPacket(1, 4, true)); |
| 2853 | // RTO 2 |
| 2854 | quic_data.AddWrite(SYNCHRONOUS, |
| 2855 | client_maker_.MakeRetransmissionPacket(1, 5, true)); |
| 2856 | // RTO 3 |
| 2857 | quic_data.AddWrite(SYNCHRONOUS, |
| 2858 | client_maker_.MakeRetransmissionPacket(1, 6, true)); |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 2859 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2860 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
| 2861 | 7, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 2862 | "No recent network activity.")); |
Fan Yang | 928f163 | 2017-12-14 18:55:22 | [diff] [blame] | 2863 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2864 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 2865 | quic_data.AddRead(ASYNC, OK); |
| 2866 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2867 | |
| 2868 | // In order for a new QUIC session to be established via alternate-protocol |
| 2869 | // without racing an HTTP connection, we need the host resolution to happen |
| 2870 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2871 | // connection to the the server, in this test we require confirmation |
| 2872 | // before encrypting so the HTTP job will still start. |
| 2873 | host_resolver_.set_synchronous_mode(true); |
| 2874 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2875 | ""); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2876 | |
| 2877 | CreateSession(); |
| 2878 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2879 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2880 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 2881 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2882 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2883 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2884 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2885 | |
| 2886 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2887 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 2888 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2889 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2890 | |
| 2891 | // Pump the message loop to get the request started. |
| 2892 | base::RunLoop().RunUntilIdle(); |
| 2893 | // Explicitly confirm the handshake. |
| 2894 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2895 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2896 | |
| 2897 | // Run the QUIC session to completion. |
| 2898 | quic_task_runner_->RunUntilIdle(); |
| 2899 | |
| 2900 | ExpectQuicAlternateProtocolMapping(); |
| 2901 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2902 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 2903 | } |
| 2904 | |
| 2905 | // Verify that if a QUIC connection RTOs, the QuicHttpStream will |
| 2906 | // return QUIC_PROTOCOL_ERROR. |
| 2907 | TEST_P(QuicNetworkTransactionTest, TooManyRtosAfterHandshakeConfirmed) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 2908 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
| 2909 | session_params_.quic_params.connection_options.push_back(quic::k5RTO); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2910 | |
| 2911 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2912 | MockQuicData quic_data(version_); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 2913 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2914 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 2915 | |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 2916 | client_maker_.set_save_packet_frames(true); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 2917 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 2918 | quic_data.AddWrite( |
| 2919 | SYNCHRONOUS, |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 2920 | client_maker_.MakeRequestHeadersPacket( |
| 2921 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| 2922 | priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr)); |
| 2923 | |
| 2924 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 2925 | // TLP 1 |
| 2926 | quic_data.AddWrite(SYNCHRONOUS, |
| 2927 | client_maker_.MakeRetransmissionPacket(1, 2, true)); |
| 2928 | // TLP 2 |
| 2929 | quic_data.AddWrite(SYNCHRONOUS, |
| 2930 | client_maker_.MakeRetransmissionPacket(1, 3, true)); |
| 2931 | // RTO 1 |
| 2932 | quic_data.AddWrite(SYNCHRONOUS, |
| 2933 | client_maker_.MakeRetransmissionPacket(1, 4, true)); |
| 2934 | // RTO 2 |
| 2935 | quic_data.AddWrite(SYNCHRONOUS, |
| 2936 | client_maker_.MakeRetransmissionPacket(1, 5, true)); |
| 2937 | // RTO 3 |
| 2938 | quic_data.AddWrite(SYNCHRONOUS, |
| 2939 | client_maker_.MakeRetransmissionPacket(1, 6, true)); |
| 2940 | // RTO 4 |
| 2941 | quic_data.AddWrite(SYNCHRONOUS, |
| 2942 | client_maker_.MakeRetransmissionPacket(1, 7, true)); |
| 2943 | // RTO 5 |
| 2944 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
| 2945 | 8, true, quic::QUIC_TOO_MANY_RTOS, |
| 2946 | "5 consecutive retransmission timeouts")); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2947 | |
| 2948 | quic_data.AddRead(ASYNC, OK); |
| 2949 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2950 | |
| 2951 | // In order for a new QUIC session to be established via alternate-protocol |
| 2952 | // without racing an HTTP connection, we need the host resolution to happen |
| 2953 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2954 | // connection to the the server, in this test we require confirmation |
| 2955 | // before encrypting so the HTTP job will still start. |
| 2956 | host_resolver_.set_synchronous_mode(true); |
| 2957 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2958 | ""); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2959 | |
| 2960 | CreateSession(); |
| 2961 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2962 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2963 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 2964 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2965 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2966 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2967 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2968 | |
| 2969 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2970 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 2971 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2972 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2973 | |
| 2974 | // Pump the message loop to get the request started. |
| 2975 | base::RunLoop().RunUntilIdle(); |
| 2976 | // Explicitly confirm the handshake. |
| 2977 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2978 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2979 | |
| 2980 | // Run the QUIC session to completion. |
| 2981 | quic_task_runner_->RunUntilIdle(); |
| 2982 | |
| 2983 | ExpectQuicAlternateProtocolMapping(); |
| 2984 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2985 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 2986 | } |
| 2987 | |
| 2988 | // Verify that if a QUIC connection RTOs, while there are no active streams |
| 2989 | // QUIC will not be marked as broken. |
| 2990 | TEST_P(QuicNetworkTransactionTest, |
| 2991 | TooManyRtosAfterHandshakeConfirmedAndStreamReset) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 2992 | session_params_.quic_params.connection_options.push_back(quic::k5RTO); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2993 | |
| 2994 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 2995 | MockQuicData quic_data(version_); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 2996 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2997 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 2998 | |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 2999 | client_maker_.set_save_packet_frames(true); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 3000 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3001 | quic_data.AddWrite( |
| 3002 | SYNCHRONOUS, |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 3003 | client_maker_.MakeRequestHeadersPacket( |
| 3004 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| 3005 | priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr)); |
| 3006 | |
| 3007 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3008 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3009 | quic_data.AddWrite(SYNCHRONOUS, |
| 3010 | client_maker_.MakeRstPacket( |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3011 | 2, true, GetNthClientInitiatedBidirectionalStreamId(0), |
| 3012 | quic::QUIC_STREAM_CANCELLED)); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3013 | // Since the headers are sent on the data stream, when the stream is reset |
| 3014 | // the headers are no longer retransmitted. |
| 3015 | client_maker_.RemoveSavedStreamFrames( |
| 3016 | GetNthClientInitiatedBidirectionalStreamId(0)); |
| 3017 | // TLP 1 |
| 3018 | quic_data.AddWrite(SYNCHRONOUS, |
| 3019 | client_maker_.MakeRetransmissionPacket(1, 3, true)); |
| 3020 | // TLP 2 |
| 3021 | quic_data.AddWrite(SYNCHRONOUS, |
| 3022 | client_maker_.MakeRetransmissionPacket(2, 4, true)); |
| 3023 | // RTO 1 |
| 3024 | quic_data.AddWrite(SYNCHRONOUS, |
| 3025 | client_maker_.MakeRetransmissionPacket(1, 5, true)); |
| 3026 | quic_data.AddWrite(SYNCHRONOUS, |
| 3027 | client_maker_.MakeRetransmissionPacket(2, 6, true)); |
| 3028 | // RTO 2 |
| 3029 | quic_data.AddWrite(SYNCHRONOUS, |
| 3030 | client_maker_.MakeRetransmissionPacket(1, 7, true)); |
| 3031 | quic_data.AddWrite(SYNCHRONOUS, |
| 3032 | client_maker_.MakeRetransmissionPacket(2, 8, true)); |
| 3033 | // RTO 3 |
| 3034 | quic_data.AddWrite(SYNCHRONOUS, |
| 3035 | client_maker_.MakeRetransmissionPacket(1, 9, true)); |
| 3036 | quic_data.AddWrite(SYNCHRONOUS, |
| 3037 | client_maker_.MakeRetransmissionPacket(2, 10, true)); |
| 3038 | // RTO 4 |
| 3039 | quic_data.AddWrite(SYNCHRONOUS, |
| 3040 | client_maker_.MakeRetransmissionPacket(1, 11, true)); |
| 3041 | quic_data.AddWrite(SYNCHRONOUS, |
| 3042 | client_maker_.MakeRetransmissionPacket(2, 12, true)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3043 | // RTO 5 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3044 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3045 | 13, true, quic::QUIC_TOO_MANY_RTOS, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3046 | "5 consecutive retransmission timeouts")); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3047 | |
| 3048 | quic_data.AddRead(ASYNC, OK); |
| 3049 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3050 | |
| 3051 | // In order for a new QUIC session to be established via alternate-protocol |
| 3052 | // without racing an HTTP connection, we need the host resolution to happen |
| 3053 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3054 | // connection to the the server, in this test we require confirmation |
| 3055 | // before encrypting so the HTTP job will still start. |
| 3056 | host_resolver_.set_synchronous_mode(true); |
| 3057 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3058 | ""); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3059 | |
| 3060 | CreateSession(); |
| 3061 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3062 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3063 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3064 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3065 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3066 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3067 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3068 | |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3069 | auto trans = std::make_unique<HttpNetworkTransaction>(DEFAULT_PRIORITY, |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3070 | session_.get()); |
| 3071 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 3072 | int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3073 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3074 | |
| 3075 | // Pump the message loop to get the request started. |
| 3076 | base::RunLoop().RunUntilIdle(); |
| 3077 | // Explicitly confirm the handshake. |
| 3078 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3079 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3080 | |
| 3081 | // Now cancel the request. |
| 3082 | trans.reset(); |
| 3083 | |
| 3084 | // Run the QUIC session to completion. |
| 3085 | quic_task_runner_->RunUntilIdle(); |
| 3086 | |
| 3087 | ExpectQuicAlternateProtocolMapping(); |
| 3088 | |
| 3089 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3090 | } |
| 3091 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3092 | // Verify that if a QUIC protocol error occurs after the handshake is confirmed |
| 3093 | // the request fails with QUIC_PROTOCOL_ERROR. |
| 3094 | TEST_P(QuicNetworkTransactionTest, ProtocolErrorAfterHandshakeConfirmed) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3095 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3096 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3097 | MockQuicData quic_data(version_); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 3098 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3099 | quic_data.AddWrite(SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3100 | ConstructClientRequestHeadersPacket( |
| 3101 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3102 | true, GetRequestHeaders("GET", "https", "/"))); |
| 3103 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 3104 | uint64_t packet_number = 2; |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3105 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3106 | // Peer sending data from an non-existing stream causes this end to raise |
| 3107 | // error and close connection. |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3108 | quic_data.AddRead( |
| 3109 | ASYNC, ConstructServerRstPacket( |
| 3110 | 1, false, GetNthClientInitiatedBidirectionalStreamId(47), |
| 3111 | quic::QUIC_STREAM_LAST_ERROR)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3112 | std::string quic_error_details = "Data for nonexistent stream"; |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 3113 | quic_data.AddWrite( |
| 3114 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket( |
| 3115 | packet_number++, quic::QuicTime::Delta::Zero(), 1, 1, 1, |
Renjie Tang | ff0d637 | 2019-08-30 22:03:29 | [diff] [blame] | 3116 | quic::QUIC_INVALID_STREAM_ID, quic_error_details, |
| 3117 | quic::IETF_RST_STREAM)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3118 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3119 | |
| 3120 | // In order for a new QUIC session to be established via alternate-protocol |
| 3121 | // without racing an HTTP connection, we need the host resolution to happen |
| 3122 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3123 | // connection to the the server, in this test we require confirmation |
| 3124 | // before encrypting so the HTTP job will still start. |
| 3125 | host_resolver_.set_synchronous_mode(true); |
| 3126 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3127 | ""); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3128 | |
| 3129 | CreateSession(); |
| 3130 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3131 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3132 | |
| 3133 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3134 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 3135 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3136 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3137 | |
| 3138 | // Pump the message loop to get the request started. |
| 3139 | base::RunLoop().RunUntilIdle(); |
| 3140 | // Explicitly confirm the handshake. |
| 3141 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3142 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3143 | |
| 3144 | ASSERT_FALSE(quic_data.AllReadDataConsumed()); |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3145 | quic_data.Resume(); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3146 | |
| 3147 | // Run the QUIC session to completion. |
| 3148 | base::RunLoop().RunUntilIdle(); |
| 3149 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3150 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 3151 | |
| 3152 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 3153 | ExpectQuicAlternateProtocolMapping(); |
| 3154 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3155 | } |
| 3156 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3157 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3158 | // connection times out, then QUIC will be marked as broken and the request |
| 3159 | // retried over TCP. |
| 3160 | TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken2) { |
Ryan Sleevi | 2e8255b | 2019-07-17 21:02:21 | [diff] [blame] | 3161 | session_params_.quic_params.idle_connection_timeout = |
| 3162 | base::TimeDelta::FromSeconds(5); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3163 | |
| 3164 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3165 | MockQuicData quic_data(version_); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 3166 | spdy::SpdyPriority priority = |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3167 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 3168 | |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 3169 | client_maker_.set_save_packet_frames(true); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 3170 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3171 | quic_data.AddWrite( |
| 3172 | SYNCHRONOUS, |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 3173 | client_maker_.MakeRequestHeadersPacket( |
| 3174 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| 3175 | priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr)); |
| 3176 | |
| 3177 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3178 | // TLP 1 |
| 3179 | quic_data.AddWrite(SYNCHRONOUS, |
| 3180 | client_maker_.MakeRetransmissionPacket(1, 2, true)); |
| 3181 | // TLP 2 |
| 3182 | quic_data.AddWrite(SYNCHRONOUS, |
| 3183 | client_maker_.MakeRetransmissionPacket(1, 3, true)); |
| 3184 | // RTO 1 |
| 3185 | quic_data.AddWrite(SYNCHRONOUS, |
| 3186 | client_maker_.MakeRetransmissionPacket(1, 4, true)); |
| 3187 | // RTO 2 |
| 3188 | quic_data.AddWrite(SYNCHRONOUS, |
| 3189 | client_maker_.MakeRetransmissionPacket(1, 5, true)); |
| 3190 | // RTO 3 |
| 3191 | quic_data.AddWrite(SYNCHRONOUS, |
| 3192 | client_maker_.MakeRetransmissionPacket(1, 6, true)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3193 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3194 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
| 3195 | 7, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 3196 | "No recent network activity.")); |
Fan Yang | 928f163 | 2017-12-14 18:55:22 | [diff] [blame] | 3197 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3198 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 3199 | quic_data.AddRead(ASYNC, OK); |
| 3200 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3201 | |
| 3202 | // After that fails, it will be resent via TCP. |
| 3203 | MockWrite http_writes[] = { |
| 3204 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3205 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3206 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3207 | |
| 3208 | MockRead http_reads[] = { |
| 3209 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3210 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3211 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3212 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3213 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3214 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3215 | |
| 3216 | // In order for a new QUIC session to be established via alternate-protocol |
| 3217 | // without racing an HTTP connection, we need the host resolution to happen |
| 3218 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3219 | // connection to the the server, in this test we require confirmation |
| 3220 | // before encrypting so the HTTP job will still start. |
| 3221 | host_resolver_.set_synchronous_mode(true); |
| 3222 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3223 | ""); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3224 | |
| 3225 | CreateSession(); |
| 3226 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3227 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3228 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3229 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3230 | &clock_)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3231 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3232 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3233 | |
| 3234 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3235 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 3236 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3237 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3238 | |
| 3239 | // Pump the message loop to get the request started. |
| 3240 | base::RunLoop().RunUntilIdle(); |
| 3241 | // Explicitly confirm the handshake. |
| 3242 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3243 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3244 | |
| 3245 | // Run the QUIC session to completion. |
| 3246 | quic_task_runner_->RunUntilIdle(); |
| 3247 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3248 | |
| 3249 | ExpectQuicAlternateProtocolMapping(); |
| 3250 | |
| 3251 | // Let the transaction proceed which will result in QUIC being marked |
| 3252 | // as broken and the request falling back to TCP. |
| 3253 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3254 | |
| 3255 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3256 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3257 | |
| 3258 | // Read the response body over TCP. |
| 3259 | CheckResponseData(&trans, "hello world"); |
| 3260 | ExpectBrokenAlternateProtocolMapping(); |
| 3261 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3262 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3263 | } |
| 3264 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3265 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3266 | // protocol error occurs after the handshake is confirmed, the request |
| 3267 | // retried over TCP and the QUIC will be marked as broken. |
| 3268 | TEST_P(QuicNetworkTransactionTest, |
| 3269 | ProtocolErrorAfterHandshakeConfirmedThenBroken) { |
Ryan Sleevi | 2e8255b | 2019-07-17 21:02:21 | [diff] [blame] | 3270 | session_params_.quic_params.idle_connection_timeout = |
| 3271 | base::TimeDelta::FromSeconds(5); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3272 | |
| 3273 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3274 | MockQuicData quic_data(version_); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 3275 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3276 | quic_data.AddWrite(SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3277 | ConstructClientRequestHeadersPacket( |
| 3278 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3279 | true, GetRequestHeaders("GET", "https", "/"))); |
| 3280 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3281 | uint64_t packet_number = 2; |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3282 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
| 3283 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3284 | // Peer sending data from an non-existing stream causes this end to raise |
| 3285 | // error and close connection. |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3286 | quic_data.AddRead( |
| 3287 | ASYNC, ConstructServerRstPacket( |
| 3288 | 1, false, GetNthClientInitiatedBidirectionalStreamId(47), |
| 3289 | quic::QUIC_STREAM_LAST_ERROR)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3290 | std::string quic_error_details = "Data for nonexistent stream"; |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3291 | quic_data.AddWrite( |
| 3292 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket( |
| 3293 | packet_number++, quic::QuicTime::Delta::Zero(), 1, 1, 1, |
Renjie Tang | ff0d637 | 2019-08-30 22:03:29 | [diff] [blame] | 3294 | quic::QUIC_INVALID_STREAM_ID, quic_error_details, |
| 3295 | quic::IETF_RST_STREAM)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3296 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3297 | |
| 3298 | // After that fails, it will be resent via TCP. |
| 3299 | MockWrite http_writes[] = { |
| 3300 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3301 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3302 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3303 | |
| 3304 | MockRead http_reads[] = { |
| 3305 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3306 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3307 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3308 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3309 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3310 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3311 | |
| 3312 | // In order for a new QUIC session to be established via alternate-protocol |
| 3313 | // without racing an HTTP connection, we need the host resolution to happen |
| 3314 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3315 | // connection to the the server, in this test we require confirmation |
| 3316 | // before encrypting so the HTTP job will still start. |
| 3317 | host_resolver_.set_synchronous_mode(true); |
| 3318 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3319 | ""); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3320 | |
| 3321 | CreateSession(); |
| 3322 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3323 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3324 | |
| 3325 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3326 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 3327 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3328 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3329 | |
| 3330 | // Pump the message loop to get the request started. |
| 3331 | base::RunLoop().RunUntilIdle(); |
| 3332 | // Explicitly confirm the handshake. |
| 3333 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3334 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3335 | quic_data.Resume(); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3336 | |
| 3337 | // Run the QUIC session to completion. |
| 3338 | base::RunLoop().RunUntilIdle(); |
| 3339 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3340 | |
| 3341 | ExpectQuicAlternateProtocolMapping(); |
| 3342 | |
| 3343 | // Let the transaction proceed which will result in QUIC being marked |
| 3344 | // as broken and the request falling back to TCP. |
| 3345 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3346 | |
| 3347 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3348 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3349 | |
| 3350 | // Read the response body over TCP. |
| 3351 | CheckResponseData(&trans, "hello world"); |
| 3352 | ExpectBrokenAlternateProtocolMapping(); |
| 3353 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3354 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3355 | } |
| 3356 | |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3357 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3358 | // request is reset from, then QUIC will be marked as broken and the request |
| 3359 | // retried over TCP. |
| 3360 | TEST_P(QuicNetworkTransactionTest, ResetAfterHandshakeConfirmedThenBroken) { |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3361 | // The request will initially go out over QUIC. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3362 | MockQuicData quic_data(version_); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 3363 | spdy::SpdyPriority priority = |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3364 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 3365 | |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 3366 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3367 | quic_data.AddWrite( |
| 3368 | SYNCHRONOUS, |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 3369 | client_maker_.MakeRequestHeadersPacket( |
| 3370 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, true, |
| 3371 | priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr)); |
| 3372 | |
| 3373 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3374 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3375 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3376 | quic_data.AddRead(ASYNC, |
| 3377 | ConstructServerRstPacket( |
| 3378 | 1, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 3379 | quic::QUIC_HEADERS_TOO_LARGE)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3380 | |
| 3381 | quic_data.AddRead(ASYNC, OK); |
| 3382 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3383 | |
| 3384 | // After that fails, it will be resent via TCP. |
| 3385 | MockWrite http_writes[] = { |
| 3386 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3387 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3388 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3389 | |
| 3390 | MockRead http_reads[] = { |
| 3391 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3392 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3393 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3394 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3395 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3396 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3397 | |
| 3398 | // In order for a new QUIC session to be established via alternate-protocol |
| 3399 | // without racing an HTTP connection, we need the host resolution to happen |
| 3400 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3401 | // connection to the the server, in this test we require confirmation |
| 3402 | // before encrypting so the HTTP job will still start. |
| 3403 | host_resolver_.set_synchronous_mode(true); |
| 3404 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3405 | ""); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3406 | |
| 3407 | CreateSession(); |
| 3408 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3409 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3410 | |
| 3411 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3412 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 3413 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3414 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3415 | |
| 3416 | // Pump the message loop to get the request started. |
| 3417 | base::RunLoop().RunUntilIdle(); |
| 3418 | // Explicitly confirm the handshake. |
| 3419 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3420 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
Ryan Hamilton | b01f886f | 2019-07-10 02:25:55 | [diff] [blame] | 3421 | quic_data.Resume(); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3422 | |
| 3423 | // Run the QUIC session to completion. |
| 3424 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3425 | |
| 3426 | ExpectQuicAlternateProtocolMapping(); |
| 3427 | |
| 3428 | // Let the transaction proceed which will result in QUIC being marked |
| 3429 | // as broken and the request falling back to TCP. |
| 3430 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3431 | |
| 3432 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3433 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3434 | |
| 3435 | // Read the response body over TCP. |
| 3436 | CheckResponseData(&trans, "hello world"); |
| 3437 | ExpectBrokenAlternateProtocolMapping(); |
| 3438 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3439 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3440 | } |
| 3441 | |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3442 | // Verify that when an origin has two alt-svc advertisements, one local and one |
| 3443 | // remote, that when the local is broken the request will go over QUIC via |
| 3444 | // the remote Alt-Svc. |
| 3445 | // This is a regression test for crbug/825646. |
| 3446 | TEST_P(QuicNetworkTransactionTest, RemoteAltSvcWorkingWhileLocalAltSvcBroken) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3447 | session_params_.quic_params.allow_remote_alt_svc = true; |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3448 | |
| 3449 | GURL origin1 = request_.url; // mail.example.org |
| 3450 | GURL origin2("https://www.example.org/"); |
| 3451 | ASSERT_NE(origin1.host(), origin2.host()); |
| 3452 | |
| 3453 | scoped_refptr<X509Certificate> cert( |
| 3454 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 3455 | ASSERT_TRUE(cert->VerifyNameMatch("www.example.org")); |
| 3456 | ASSERT_TRUE(cert->VerifyNameMatch("mail.example.org")); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3457 | |
| 3458 | ProofVerifyDetailsChromium verify_details; |
| 3459 | verify_details.cert_verify_result.verified_cert = cert; |
| 3460 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 3461 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 3462 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3463 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3464 | int packet_num = 1; |
| 3465 | if (VersionUsesQpack(version_.transport_version)) { |
| 3466 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3467 | ConstructInitialSettingsPacket(packet_num++)); |
| 3468 | } |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3469 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3470 | SYNCHRONOUS, |
| 3471 | ConstructClientRequestHeadersPacket( |
| 3472 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3473 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3474 | mock_quic_data.AddRead( |
| 3475 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3476 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3477 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 3478 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3479 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3480 | ASYNC, ConstructServerDataPacket( |
| 3481 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3482 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3483 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3484 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3485 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 3486 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 3487 | |
| 3488 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3489 | MockQuicData mock_quic_data2(version_); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3490 | mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 3491 | AddHangingNonAlternateProtocolSocketData(); |
| 3492 | |
| 3493 | CreateSession(); |
| 3494 | |
| 3495 | // Set up alternative service for |origin1|. |
| 3496 | AlternativeService local_alternative(kProtoQUIC, "mail.example.org", 443); |
| 3497 | AlternativeService remote_alternative(kProtoQUIC, "www.example.org", 443); |
| 3498 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| 3499 | AlternativeServiceInfoVector alternative_services; |
| 3500 | alternative_services.push_back( |
| 3501 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 3502 | local_alternative, expiration, |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3503 | session_->params().quic_params.supported_versions)); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3504 | alternative_services.push_back( |
| 3505 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 3506 | remote_alternative, expiration, |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3507 | session_->params().quic_params.supported_versions)); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3508 | http_server_properties_->SetAlternativeServices(url::SchemeHostPort(origin1), |
| 3509 | NetworkIsolationKey(), |
| 3510 | alternative_services); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3511 | |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3512 | http_server_properties_->MarkAlternativeServiceBroken(local_alternative); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3513 | |
| 3514 | SendRequestAndExpectQuicResponse("hello!"); |
| 3515 | } |
| 3516 | |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3517 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3518 | // request is reset from, then QUIC will be marked as broken and the request |
| 3519 | // retried over TCP. Then, subsequent requests will go over a new QUIC |
| 3520 | // connection instead of going back to the broken QUIC connection. |
| 3521 | // This is a regression tests for crbug/731303. |
| 3522 | TEST_P(QuicNetworkTransactionTest, |
| 3523 | ResetPooledAfterHandshakeConfirmedThenBroken) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3524 | session_params_.quic_params.allow_remote_alt_svc = true; |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3525 | |
| 3526 | GURL origin1 = request_.url; |
| 3527 | GURL origin2("https://www.example.org/"); |
| 3528 | ASSERT_NE(origin1.host(), origin2.host()); |
| 3529 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3530 | MockQuicData mock_quic_data(version_); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3531 | |
| 3532 | scoped_refptr<X509Certificate> cert( |
| 3533 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 3534 | ASSERT_TRUE(cert->VerifyNameMatch("www.example.org")); |
| 3535 | ASSERT_TRUE(cert->VerifyNameMatch("mail.example.org")); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3536 | |
| 3537 | ProofVerifyDetailsChromium verify_details; |
| 3538 | verify_details.cert_verify_result.verified_cert = cert; |
| 3539 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 3540 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 3541 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3542 | int packet_num = 1; |
| 3543 | if (VersionUsesQpack(version_.transport_version)) { |
| 3544 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3545 | ConstructInitialSettingsPacket(packet_num++)); |
| 3546 | } |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3547 | // First request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3548 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3549 | SYNCHRONOUS, |
| 3550 | ConstructClientRequestHeadersPacket( |
| 3551 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3552 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3553 | mock_quic_data.AddRead( |
| 3554 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3555 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3556 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 3557 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3558 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3559 | ASYNC, ConstructServerDataPacket( |
| 3560 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3561 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3562 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3563 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3564 | |
| 3565 | // Second request will go over the pooled QUIC connection, but will be |
| 3566 | // reset by the server. |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 3567 | QuicTestPacketMaker client_maker2( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 3568 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 3569 | &clock_, origin2.host(), quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 3570 | client_headers_include_h2_stream_dependency_); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 3571 | QuicTestPacketMaker server_maker2( |
| 3572 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 3573 | &clock_, origin2.host(), quic::Perspective::IS_SERVER, false); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3574 | mock_quic_data.AddWrite( |
| 3575 | SYNCHRONOUS, |
| 3576 | ConstructClientRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3577 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 3578 | true, GetRequestHeaders("GET", "https", "/", &client_maker2), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3579 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3580 | mock_quic_data.AddRead( |
| 3581 | ASYNC, ConstructServerRstPacket( |
| 3582 | 3, false, GetNthClientInitiatedBidirectionalStreamId(1), |
| 3583 | quic::QUIC_HEADERS_TOO_LARGE)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3584 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 3585 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 3586 | |
| 3587 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3588 | |
| 3589 | // After that fails, it will be resent via TCP. |
| 3590 | MockWrite http_writes[] = { |
| 3591 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3592 | MockWrite(SYNCHRONOUS, 1, "Host: www.example.org\r\n"), |
| 3593 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3594 | |
| 3595 | MockRead http_reads[] = { |
| 3596 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3597 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3598 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3599 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3600 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3601 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3602 | |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3603 | // Then the next request to the second origin will be sent over TCP. |
| 3604 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3605 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3606 | |
| 3607 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 3608 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3609 | session_->quic_stream_factory(), |
| 3610 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 3611 | &clock_)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3612 | |
| 3613 | // Set up alternative service for |origin1|. |
| 3614 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 3615 | AlternativeService alternative1(kProtoQUIC, origin1.host(), 443); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3616 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 3617 | url::SchemeHostPort(origin1), NetworkIsolationKey(), alternative1, |
| 3618 | expiration, supported_versions_); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3619 | |
| 3620 | // Set up alternative service for |origin2|. |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 3621 | AlternativeService alternative2(kProtoQUIC, origin2.host(), 443); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3622 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 3623 | url::SchemeHostPort(origin2), NetworkIsolationKey(), alternative2, |
| 3624 | expiration, supported_versions_); |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 3625 | |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3626 | // First request opens connection to |destination1| |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3627 | // with quic::QuicServerId.host() == origin1.host(). |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3628 | SendRequestAndExpectQuicResponse("hello!"); |
| 3629 | |
| 3630 | // Second request pools to existing connection with same destination, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3631 | // because certificate matches, even though quic::QuicServerId is different. |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3632 | // After it is reset, it will fail back to QUIC and mark QUIC as broken. |
| 3633 | request_.url = origin2; |
| 3634 | SendRequestAndExpectHttpResponse("hello world"); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3635 | EXPECT_FALSE( |
| 3636 | http_server_properties_->IsAlternativeServiceBroken(alternative1)) |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 3637 | << alternative1.ToString(); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3638 | EXPECT_TRUE(http_server_properties_->IsAlternativeServiceBroken(alternative2)) |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 3639 | << alternative2.ToString(); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3640 | |
| 3641 | // The third request should use a new QUIC connection, not the broken |
| 3642 | // QUIC connection. |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3643 | SendRequestAndExpectHttpResponse("hello world"); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3644 | } |
| 3645 | |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 3646 | TEST_P(QuicNetworkTransactionTest, |
| 3647 | DoNotUseAlternativeServiceQuicUnsupportedVersion) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 3648 | std::string altsvc_header = |
| 3649 | base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", |
| 3650 | version_.transport_version - 1); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 3651 | MockRead http_reads[] = { |
| 3652 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 3653 | MockRead("hello world"), |
| 3654 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 3655 | MockRead(ASYNC, OK)}; |
| 3656 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3657 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 3658 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3659 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3660 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3661 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3662 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 3663 | CreateSession(); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 3664 | |
| 3665 | SendRequestAndExpectHttpResponse("hello world"); |
| 3666 | SendRequestAndExpectHttpResponse("hello world"); |
| 3667 | } |
| 3668 | |
Xida Chen | 9bfe0b6 | 2018-04-24 19:52:21 | [diff] [blame] | 3669 | // When multiple alternative services are advertised, HttpStreamFactory should |
| 3670 | // select the alternative service which uses existing QUIC session if available. |
| 3671 | // If no existing QUIC session can be used, use the first alternative service |
| 3672 | // from the list. |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3673 | TEST_P(QuicNetworkTransactionTest, UseExistingAlternativeServiceForQuic) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3674 | session_params_.quic_params.allow_remote_alt_svc = true; |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 3675 | MockRead http_reads[] = { |
| 3676 | MockRead("HTTP/1.1 200 OK\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 3677 | MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 3678 | MockRead("hello world"), |
| 3679 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 3680 | MockRead(ASYNC, OK)}; |
| 3681 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3682 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 3683 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 3684 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 3685 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 3686 | |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3687 | // First QUIC request data. |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 3688 | // Open a session to foo.example.org:443 using the first entry of the |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3689 | // alternative service list. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3690 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3691 | int packet_num = 1; |
| 3692 | if (VersionUsesQpack(version_.transport_version)) { |
| 3693 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3694 | ConstructInitialSettingsPacket(packet_num++)); |
| 3695 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 3696 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3697 | SYNCHRONOUS, |
| 3698 | ConstructClientRequestHeadersPacket( |
| 3699 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3700 | true, GetRequestHeaders("GET", "https", "/"))); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3701 | |
| 3702 | std::string alt_svc_list = |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 3703 | "quic=\"mail.example.org:444\", quic=\"foo.example.org:443\", " |
| 3704 | "quic=\"bar.example.org:445\""; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3705 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3706 | ASYNC, ConstructServerResponseHeadersPacket( |
| 3707 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 3708 | GetResponseHeaders("200 OK", alt_svc_list))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 3709 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3710 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3711 | ASYNC, ConstructServerDataPacket( |
| 3712 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3713 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3714 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3715 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3716 | |
| 3717 | // Second QUIC request data. |
| 3718 | // Connection pooling, using existing session, no need to include version |
| 3719 | // as version negotiation has been completed. |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 3720 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3721 | SYNCHRONOUS, |
| 3722 | ConstructClientRequestHeadersPacket( |
| 3723 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 3724 | true, GetRequestHeaders("GET", "https", "/"), |
| 3725 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3726 | mock_quic_data.AddRead( |
| 3727 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3728 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3729 | GetResponseHeaders("200 OK"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3730 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3731 | ASYNC, ConstructServerDataPacket( |
| 3732 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3733 | header + "hello!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3734 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3735 | SYNCHRONOUS, |
| 3736 | ConstructClientAckAndConnectionClosePacket(packet_num++, 4, 3, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 3737 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 3738 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 3739 | |
| 3740 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3741 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 3742 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 3743 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 3744 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3745 | session_->quic_stream_factory(), |
| 3746 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 3747 | &clock_)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 3748 | |
| 3749 | SendRequestAndExpectHttpResponse("hello world"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3750 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3751 | SendRequestAndExpectQuicResponse("hello!"); |
| 3752 | SendRequestAndExpectQuicResponse("hello!"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3753 | } |
| 3754 | |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3755 | // Check that an existing QUIC connection to an alternative proxy server is |
| 3756 | // used. |
| 3757 | TEST_P(QuicNetworkTransactionTest, UseExistingQUICAlternativeProxy) { |
| 3758 | base::HistogramTester histogram_tester; |
| 3759 | |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3760 | // First QUIC request data. |
| 3761 | // Open a session to foo.example.org:443 using the first entry of the |
| 3762 | // alternative service list. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3763 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3764 | int packet_num = 1; |
| 3765 | if (VersionUsesQpack(version_.transport_version)) { |
| 3766 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3767 | ConstructInitialSettingsPacket(packet_num++)); |
| 3768 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 3769 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3770 | SYNCHRONOUS, |
| 3771 | ConstructClientRequestHeadersPacket( |
| 3772 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3773 | true, GetRequestHeaders("GET", "http", "/"))); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3774 | |
| 3775 | std::string alt_svc_list; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3776 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3777 | ASYNC, ConstructServerResponseHeadersPacket( |
| 3778 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 3779 | GetResponseHeaders("200 OK", alt_svc_list))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 3780 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3781 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3782 | ASYNC, ConstructServerDataPacket( |
| 3783 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3784 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3785 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3786 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3787 | |
| 3788 | // Second QUIC request data. |
| 3789 | // Connection pooling, using existing session, no need to include version |
| 3790 | // as version negotiation has been completed. |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3791 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3792 | SYNCHRONOUS, |
| 3793 | ConstructClientRequestHeadersPacket( |
| 3794 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 3795 | true, GetRequestHeaders("GET", "http", "/"), |
| 3796 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3797 | mock_quic_data.AddRead( |
| 3798 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3799 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3800 | GetResponseHeaders("200 OK"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3801 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3802 | ASYNC, ConstructServerDataPacket( |
| 3803 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3804 | header + "hello!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3805 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3806 | SYNCHRONOUS, |
| 3807 | ConstructClientAckAndConnectionClosePacket(packet_num++, 4, 3, 1)); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3808 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 3809 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 3810 | |
| 3811 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3812 | |
| 3813 | AddHangingNonAlternateProtocolSocketData(); |
| 3814 | |
| 3815 | TestProxyDelegate test_proxy_delegate; |
| 3816 | |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 3817 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 3818 | "HTTPS mail.example.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3819 | |
| 3820 | test_proxy_delegate.set_alternative_proxy_server( |
| 3821 | ProxyServer::FromPacString("QUIC mail.example.org:443")); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 3822 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3823 | |
| 3824 | request_.url = GURL("http://mail.example.org/"); |
| 3825 | |
| 3826 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 3827 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3828 | session_->quic_stream_factory(), |
| 3829 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 3830 | &clock_)); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 3831 | |
| 3832 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443); |
| 3833 | histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage", |
| 3834 | 1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */, |
| 3835 | 1); |
| 3836 | |
| 3837 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443); |
| 3838 | histogram_tester.ExpectTotalCount("Net.QuicAlternativeProxy.Usage", 2); |
| 3839 | histogram_tester.ExpectBucketCount("Net.QuicAlternativeProxy.Usage", |
| 3840 | 0 /* ALTERNATIVE_PROXY_USAGE_NO_RACE */, |
| 3841 | 1); |
| 3842 | } |
| 3843 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3844 | // Pool to existing session with matching quic::QuicServerId |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3845 | // even if alternative service destination is different. |
| 3846 | TEST_P(QuicNetworkTransactionTest, PoolByOrigin) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3847 | session_params_.quic_params.allow_remote_alt_svc = true; |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3848 | MockQuicData mock_quic_data(version_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3849 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3850 | int packet_num = 1; |
| 3851 | if (VersionUsesQpack(version_.transport_version)) { |
| 3852 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3853 | ConstructInitialSettingsPacket(packet_num++)); |
| 3854 | } |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3855 | // First request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3856 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3857 | SYNCHRONOUS, |
| 3858 | ConstructClientRequestHeadersPacket( |
| 3859 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3860 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3861 | mock_quic_data.AddRead( |
| 3862 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3863 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3864 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 3865 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3866 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3867 | ASYNC, ConstructServerDataPacket( |
| 3868 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3869 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3870 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3871 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3872 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3873 | // Second request. |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 3874 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3875 | SYNCHRONOUS, |
| 3876 | ConstructClientRequestHeadersPacket( |
| 3877 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 3878 | true, GetRequestHeaders("GET", "https", "/"), |
| 3879 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3880 | mock_quic_data.AddRead( |
| 3881 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3882 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3883 | GetResponseHeaders("200 OK"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3884 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3885 | ASYNC, ConstructServerDataPacket( |
| 3886 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3887 | header + "hello!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3888 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3889 | SYNCHRONOUS, |
| 3890 | ConstructClientAckAndConnectionClosePacket(packet_num++, 4, 3, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3891 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 3892 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 3893 | |
| 3894 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3895 | |
| 3896 | AddHangingNonAlternateProtocolSocketData(); |
| 3897 | AddHangingNonAlternateProtocolSocketData(); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3898 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 3899 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 3900 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3901 | session_->quic_stream_factory(), |
| 3902 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 3903 | &clock_)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 3904 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3905 | const char destination1[] = "first.example.com"; |
| 3906 | const char destination2[] = "second.example.com"; |
| 3907 | |
| 3908 | // Set up alternative service entry to destination1. |
| 3909 | url::SchemeHostPort server(request_.url); |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 3910 | AlternativeService alternative_service(kProtoQUIC, destination1, 443); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3911 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3912 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 3913 | server, NetworkIsolationKey(), alternative_service, expiration, |
| 3914 | supported_versions_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3915 | // First request opens connection to |destination1| |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3916 | // with quic::QuicServerId.host() == kDefaultServerHostName. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3917 | SendRequestAndExpectQuicResponse("hello!"); |
| 3918 | |
| 3919 | // Set up alternative service entry to a different destination. |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 3920 | alternative_service = AlternativeService(kProtoQUIC, destination2, 443); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 3921 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 3922 | server, NetworkIsolationKey(), alternative_service, expiration, |
| 3923 | supported_versions_); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3924 | // Second request pools to existing connection with same quic::QuicServerId, |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3925 | // even though alternative service destination is different. |
| 3926 | SendRequestAndExpectQuicResponse("hello!"); |
| 3927 | } |
| 3928 | |
| 3929 | // Pool to existing session with matching destination and matching certificate |
| 3930 | // even if origin is different, and even if the alternative service with |
| 3931 | // matching destination is not the first one on the list. |
| 3932 | TEST_P(QuicNetworkTransactionTest, PoolByDestination) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 3933 | session_params_.quic_params.allow_remote_alt_svc = true; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3934 | GURL origin1 = request_.url; |
| 3935 | GURL origin2("https://www.example.org/"); |
| 3936 | ASSERT_NE(origin1.host(), origin2.host()); |
| 3937 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 3938 | MockQuicData mock_quic_data(version_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3939 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3940 | int packet_num = 1; |
| 3941 | if (VersionUsesQpack(version_.transport_version)) { |
| 3942 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3943 | ConstructInitialSettingsPacket(packet_num++)); |
| 3944 | } |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3945 | // First request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3946 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3947 | SYNCHRONOUS, |
| 3948 | ConstructClientRequestHeadersPacket( |
| 3949 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 3950 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3951 | mock_quic_data.AddRead( |
| 3952 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3953 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3954 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 3955 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3956 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3957 | ASYNC, ConstructServerDataPacket( |
| 3958 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3959 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3960 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 3961 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3962 | |
| 3963 | // Second request. |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 3964 | QuicTestPacketMaker client_maker2( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 3965 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 3966 | &clock_, origin2.host(), quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 3967 | client_headers_include_h2_stream_dependency_); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 3968 | QuicTestPacketMaker server_maker2( |
| 3969 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 3970 | &clock_, origin2.host(), quic::Perspective::IS_SERVER, false); |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 3971 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3972 | SYNCHRONOUS, |
| 3973 | ConstructClientRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3974 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 3975 | true, GetRequestHeaders("GET", "https", "/", &client_maker2), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3976 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3977 | mock_quic_data.AddRead( |
| 3978 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3979 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 3980 | GetResponseHeaders("200 OK"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3981 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 3982 | ASYNC, ConstructServerDataPacket( |
| 3983 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 3984 | header + "hello!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3985 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 3986 | SYNCHRONOUS, |
| 3987 | ConstructClientAckAndConnectionClosePacket(packet_num++, 4, 3, 1)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 3988 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 3989 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 3990 | |
| 3991 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3992 | |
| 3993 | AddHangingNonAlternateProtocolSocketData(); |
| 3994 | AddHangingNonAlternateProtocolSocketData(); |
| 3995 | |
| 3996 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 3997 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3998 | session_->quic_stream_factory(), |
| 3999 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4000 | &clock_)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4001 | |
| 4002 | const char destination1[] = "first.example.com"; |
| 4003 | const char destination2[] = "second.example.com"; |
| 4004 | |
| 4005 | // Set up alternative service for |origin1|. |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4006 | AlternativeService alternative_service1(kProtoQUIC, destination1, 443); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4007 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 4008 | http_server_properties_->SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 4009 | url::SchemeHostPort(origin1), NetworkIsolationKey(), alternative_service1, |
| 4010 | expiration, supported_versions_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4011 | |
| 4012 | // Set up multiple alternative service entries for |origin2|, |
| 4013 | // the first one with a different destination as for |origin1|, |
| 4014 | // the second one with the same. The second one should be used, |
| 4015 | // because the request can be pooled to that one. |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4016 | AlternativeService alternative_service2(kProtoQUIC, destination2, 443); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4017 | AlternativeServiceInfoVector alternative_services; |
| 4018 | alternative_services.push_back( |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4019 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 4020 | alternative_service2, expiration, |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 4021 | session_->params().quic_params.supported_versions)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4022 | alternative_services.push_back( |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4023 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 4024 | alternative_service1, expiration, |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 4025 | session_->params().quic_params.supported_versions)); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 4026 | http_server_properties_->SetAlternativeServices(url::SchemeHostPort(origin2), |
| 4027 | NetworkIsolationKey(), |
| 4028 | alternative_services); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4029 | // First request opens connection to |destination1| |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4030 | // with quic::QuicServerId.host() == origin1.host(). |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4031 | SendRequestAndExpectQuicResponse("hello!"); |
| 4032 | |
| 4033 | // Second request pools to existing connection with same destination, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4034 | // because certificate matches, even though quic::QuicServerId is different. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4035 | request_.url = origin2; |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4036 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4037 | SendRequestAndExpectQuicResponse("hello!"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4038 | } |
| 4039 | |
| 4040 | // Multiple origins have listed the same alternative services. When there's a |
| 4041 | // existing QUIC session opened by a request to other origin, |
| 4042 | // if the cert is valid, should select this QUIC session to make the request |
| 4043 | // if this is also the first existing QUIC session. |
| 4044 | TEST_P(QuicNetworkTransactionTest, |
| 4045 | UseSharedExistingAlternativeServiceForQuicWithValidCert) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 4046 | session_params_.quic_params.allow_remote_alt_svc = true; |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4047 | // Default cert is valid for *.example.org |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4048 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4049 | // HTTP data for request to www.example.org. |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4050 | MockRead http_reads[] = { |
| 4051 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 4052 | MockRead("Alt-Svc: quic=\":443\"\r\n\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4053 | MockRead("hello world from www.example.org"), |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4054 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4055 | MockRead(ASYNC, OK)}; |
| 4056 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4057 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4058 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4059 | AddCertificate(&ssl_data_); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4060 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 4061 | |
| 4062 | // HTTP data for request to mail.example.org. |
| 4063 | MockRead http_reads2[] = { |
| 4064 | MockRead("HTTP/1.1 200 OK\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4065 | MockRead("Alt-Svc: quic=\":444\", quic=\"www.example.org:443\"\r\n\r\n"), |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4066 | MockRead("hello world from mail.example.org"), |
| 4067 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4068 | MockRead(ASYNC, OK)}; |
| 4069 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4070 | StaticSocketDataProvider http_data2(http_reads2, base::span<MockWrite>()); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4071 | socket_factory_.AddSocketDataProvider(&http_data2); |
| 4072 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 4073 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 4074 | QuicTestPacketMaker client_maker( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 4075 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 4076 | &clock_, "mail.example.org", quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 4077 | client_headers_include_h2_stream_dependency_); |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4078 | server_maker_.set_hostname("www.example.org"); |
| 4079 | client_maker_.set_hostname("www.example.org"); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4080 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4081 | int packet_num = 1; |
| 4082 | if (VersionUsesQpack(version_.transport_version)) { |
| 4083 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4084 | ConstructInitialSettingsPacket(packet_num++)); |
| 4085 | } |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4086 | // First QUIC request data. |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4087 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4088 | SYNCHRONOUS, |
| 4089 | ConstructClientRequestHeadersPacket( |
| 4090 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4091 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4092 | |
| 4093 | mock_quic_data.AddRead( |
| 4094 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4095 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4096 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4097 | std::string header = ConstructDataHeader(21); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4098 | mock_quic_data.AddRead( |
| 4099 | ASYNC, ConstructServerDataPacket( |
| 4100 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4101 | header + "hello from mail QUIC!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4102 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4103 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4104 | // Second QUIC request data. |
| 4105 | mock_quic_data.AddWrite( |
| 4106 | SYNCHRONOUS, |
| 4107 | ConstructClientRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4108 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 4109 | true, GetRequestHeaders("GET", "https", "/", &client_maker), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4110 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4111 | mock_quic_data.AddRead( |
| 4112 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4113 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4114 | GetResponseHeaders("200 OK"))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4115 | mock_quic_data.AddRead( |
| 4116 | ASYNC, ConstructServerDataPacket( |
| 4117 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4118 | header + "hello from mail QUIC!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4119 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4120 | SYNCHRONOUS, |
| 4121 | ConstructClientAckAndConnectionClosePacket(packet_num++, 4, 3, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4122 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4123 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4124 | |
| 4125 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4126 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4127 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4128 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 4129 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4130 | session_->quic_stream_factory(), |
| 4131 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4132 | &clock_)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4133 | |
| 4134 | // Send two HTTP requests, responses set up alt-svc lists for the origins. |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4135 | request_.url = GURL("https://www.example.org/"); |
| 4136 | SendRequestAndExpectHttpResponse("hello world from www.example.org"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4137 | request_.url = GURL("https://mail.example.org/"); |
| 4138 | SendRequestAndExpectHttpResponse("hello world from mail.example.org"); |
| 4139 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4140 | // Open a QUIC session to mail.example.org:443 when making request |
| 4141 | // to mail.example.org. |
| 4142 | request_.url = GURL("https://www.example.org/"); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4143 | SendRequestAndExpectQuicResponse("hello from mail QUIC!"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4144 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4145 | // Uses the existing QUIC session when making request to www.example.org. |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4146 | request_.url = GURL("https://mail.example.org/"); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4147 | SendRequestAndExpectQuicResponse("hello from mail QUIC!"); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4148 | } |
| 4149 | |
| 4150 | TEST_P(QuicNetworkTransactionTest, AlternativeServiceDifferentPort) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4151 | MockRead http_reads[] = { |
| 4152 | MockRead("HTTP/1.1 200 OK\r\n"), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4153 | MockRead(kQuicAlternativeServiceDifferentPortHeader), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4154 | MockRead("hello world"), |
| 4155 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4156 | MockRead(ASYNC, OK)}; |
| 4157 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4158 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4159 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4160 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4161 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4162 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4163 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4164 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4165 | |
| 4166 | SendRequestAndExpectHttpResponse("hello world"); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4167 | |
| 4168 | url::SchemeHostPort http_server("https", kDefaultServerHostName, 443); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 4169 | AlternativeServiceInfoVector alternative_service_info_vector = |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 4170 | http_server_properties_->GetAlternativeServiceInfos( |
| 4171 | http_server, NetworkIsolationKey()); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 4172 | ASSERT_EQ(1u, alternative_service_info_vector.size()); |
| 4173 | const AlternativeService alternative_service = |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 4174 | alternative_service_info_vector[0].alternative_service(); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 4175 | EXPECT_EQ(kProtoQUIC, alternative_service.protocol); |
| 4176 | EXPECT_EQ(kDefaultServerHostName, alternative_service.host); |
| 4177 | EXPECT_EQ(137, alternative_service.port); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4178 | } |
| 4179 | |
| 4180 | TEST_P(QuicNetworkTransactionTest, ConfirmAlternativeService) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4181 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4182 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 4183 | MockRead("hello world"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4184 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4185 | MockRead(ASYNC, OK)}; |
| 4186 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4187 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4188 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4189 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4190 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4191 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4192 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4193 | int packet_num = 1; |
| 4194 | if (VersionUsesQpack(version_.transport_version)) { |
| 4195 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4196 | ConstructInitialSettingsPacket(packet_num++)); |
| 4197 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4198 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4199 | SYNCHRONOUS, |
| 4200 | ConstructClientRequestHeadersPacket( |
| 4201 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4202 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4203 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4204 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4205 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4206 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4207 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4208 | mock_quic_data.AddRead( |
| 4209 | ASYNC, ConstructServerDataPacket( |
| 4210 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4211 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4212 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4213 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4214 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4215 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4216 | |
| 4217 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4218 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4219 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4220 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4221 | |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4222 | AlternativeService alternative_service(kProtoQUIC, |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4223 | HostPortPair::FromURL(request_.url)); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 4224 | http_server_properties_->MarkAlternativeServiceRecentlyBroken( |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4225 | alternative_service); |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 4226 | EXPECT_TRUE(http_server_properties_->WasAlternativeServiceRecentlyBroken( |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4227 | alternative_service)); |
| 4228 | |
| 4229 | SendRequestAndExpectHttpResponse("hello world"); |
| 4230 | SendRequestAndExpectQuicResponse("hello!"); |
| 4231 | |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4232 | mock_quic_data.Resume(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4233 | |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 4234 | EXPECT_FALSE(http_server_properties_->WasAlternativeServiceRecentlyBroken( |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4235 | alternative_service)); |
Matt Menke | 19475f7 | 2019-08-21 18:57:44 | [diff] [blame] | 4236 | EXPECT_NE(nullptr, http_server_properties_->GetServerNetworkStats( |
| 4237 | url::SchemeHostPort("https", request_.url.host(), 443), |
| 4238 | NetworkIsolationKey())); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4239 | } |
| 4240 | |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4241 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuicForHttps) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4242 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4243 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 4244 | MockRead("hello world"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4245 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4246 | MockRead(ASYNC, OK)}; |
| 4247 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4248 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4249 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4250 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4251 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4252 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4253 | int packet_num = 1; |
| 4254 | if (VersionUsesQpack(version_.transport_version)) { |
| 4255 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4256 | ConstructInitialSettingsPacket(packet_num++)); |
| 4257 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4258 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4259 | SYNCHRONOUS, |
| 4260 | ConstructClientRequestHeadersPacket( |
| 4261 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4262 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4263 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4264 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4265 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4266 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4267 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4268 | mock_quic_data.AddRead( |
| 4269 | ASYNC, ConstructServerDataPacket( |
| 4270 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4271 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4272 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4273 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4274 | mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF |
| 4275 | |
| 4276 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4277 | |
| 4278 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4279 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4280 | |
| 4281 | // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo(). |
| 4282 | SendRequestAndExpectHttpResponse("hello world"); |
| 4283 | } |
| 4284 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4285 | // Tests that the connection to an HTTPS proxy is raced with an available |
| 4286 | // alternative proxy server. |
| 4287 | TEST_P(QuicNetworkTransactionTest, QuicProxyWithRacing) { |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4288 | base::HistogramTester histogram_tester; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 4289 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 4290 | "HTTPS mail.example.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4291 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4292 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4293 | int packet_num = 1; |
| 4294 | if (VersionUsesQpack(version_.transport_version)) { |
| 4295 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4296 | ConstructInitialSettingsPacket(packet_num++)); |
| 4297 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4298 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4299 | SYNCHRONOUS, |
| 4300 | ConstructClientRequestHeadersPacket( |
| 4301 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4302 | true, GetRequestHeaders("GET", "http", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4303 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4304 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4305 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4306 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4307 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4308 | mock_quic_data.AddRead( |
| 4309 | ASYNC, ConstructServerDataPacket( |
| 4310 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4311 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4312 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4313 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4314 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4315 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4316 | |
| 4317 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4318 | |
| 4319 | // There is no need to set up main job, because no attempt will be made to |
| 4320 | // speak to the proxy over TCP. |
| 4321 | request_.url = GURL("http://mail.example.org/"); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4322 | TestProxyDelegate test_proxy_delegate; |
| 4323 | const HostPortPair host_port_pair("mail.example.org", 443); |
| 4324 | |
| 4325 | test_proxy_delegate.set_alternative_proxy_server( |
| 4326 | ProxyServer::FromPacString("QUIC mail.example.org:443")); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 4327 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4328 | CreateSession(); |
| 4329 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 4330 | |
| 4331 | // The main job needs to hang in order to guarantee that the alternative |
| 4332 | // proxy server job will "win". |
| 4333 | AddHangingNonAlternateProtocolSocketData(); |
| 4334 | |
| 4335 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443); |
| 4336 | |
| 4337 | // Verify that the alternative proxy server is not marked as broken. |
| 4338 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 4339 | |
| 4340 | // Verify that the proxy server is not marked as broken. |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 4341 | EXPECT_TRUE(session_->proxy_resolution_service()->proxy_retry_info().empty()); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4342 | |
| 4343 | histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage", |
| 4344 | 1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */, |
| 4345 | 1); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4346 | } |
| 4347 | |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 4348 | TEST_P(QuicNetworkTransactionTest, HungAlternativeService) { |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4349 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4350 | MockCryptoClientStream::COLD_START); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4351 | |
| 4352 | MockWrite http_writes[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4353 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4354 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4355 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4356 | |
| 4357 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4358 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 4359 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4360 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4361 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4362 | SequencedSocketData http_data(http_reads, http_writes); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4363 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4364 | AddCertificate(&ssl_data_); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4365 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4366 | |
| 4367 | // The QUIC transaction will not be allowed to complete. |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4368 | MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 1)}; |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4369 | MockRead quic_reads[] = { |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4370 | MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0), |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4371 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4372 | SequencedSocketData quic_data(quic_reads, quic_writes); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4373 | socket_factory_.AddSocketDataProvider(&quic_data); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4374 | |
| 4375 | // The HTTP transaction will complete. |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4376 | SequencedSocketData http_data2(http_reads, http_writes); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4377 | socket_factory_.AddSocketDataProvider(&http_data2); |
| 4378 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4379 | |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4380 | CreateSession(); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4381 | |
| 4382 | // Run the first request. |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4383 | SendRequestAndExpectHttpResponse("hello world"); |
rch | 37de576c | 2015-05-17 20:28:17 | [diff] [blame] | 4384 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 4385 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4386 | |
| 4387 | // Now run the second request in which the QUIC socket hangs, |
| 4388 | // and verify the the transaction continues over HTTP. |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4389 | SendRequestAndExpectHttpResponse("hello world"); |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4390 | base::RunLoop().RunUntilIdle(); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4391 | |
rch | 37de576c | 2015-05-17 20:28:17 | [diff] [blame] | 4392 | ASSERT_TRUE(http_data2.AllReadDataConsumed()); |
| 4393 | ASSERT_TRUE(http_data2.AllWriteDataConsumed()); |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4394 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4395 | } |
| 4396 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4397 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4398 | MockQuicData mock_quic_data(version_); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 4399 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4400 | mock_quic_data.AddWrite( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4401 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 4402 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4403 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4404 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4405 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4406 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4407 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4408 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4409 | mock_quic_data.AddRead( |
| 4410 | ASYNC, ConstructServerDataPacket( |
| 4411 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4412 | header + "hello!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4413 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 4414 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4415 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
[email protected] | 8ba8121 | 2013-05-03 13:11:48 | [diff] [blame] | 4416 | |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 4417 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 8ba8121 | 2013-05-03 13:11:48 | [diff] [blame] | 4418 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4419 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4420 | // the alternate-protocol job will "win". |
| 4421 | AddHangingNonAlternateProtocolSocketData(); |
| 4422 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4423 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4424 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 4425 | SendRequestAndExpectQuicResponse("hello!"); |
rch | ac7f35e | 2017-03-15 20:42:30 | [diff] [blame] | 4426 | |
Matt Menke | 19475f7 | 2019-08-21 18:57:44 | [diff] [blame] | 4427 | EXPECT_EQ(nullptr, http_server_properties_->GetServerNetworkStats( |
| 4428 | url::SchemeHostPort("https", request_.url.host(), 443), |
| 4429 | NetworkIsolationKey())); |
[email protected] | 8ba8121 | 2013-05-03 13:11:48 | [diff] [blame] | 4430 | } |
| 4431 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4432 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4433 | MockQuicData mock_quic_data(version_); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 4434 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4435 | mock_quic_data.AddWrite( |
| 4436 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 4437 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4438 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4439 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4440 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4441 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4442 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4443 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4444 | mock_quic_data.AddRead( |
| 4445 | ASYNC, ConstructServerDataPacket( |
| 4446 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4447 | header + "hello!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4448 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 4449 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4450 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 4451 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 3a120a6b | 2013-06-25 01:08:27 | [diff] [blame] | 4452 | |
| 4453 | // In order for a new QUIC session to be established via alternate-protocol |
| 4454 | // without racing an HTTP connection, we need the host resolution to happen |
| 4455 | // synchronously. |
| 4456 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4457 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4458 | ""); |
[email protected] | 3a120a6b | 2013-06-25 01:08:27 | [diff] [blame] | 4459 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4460 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4461 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4462 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 3a120a6b | 2013-06-25 01:08:27 | [diff] [blame] | 4463 | SendRequestAndExpectQuicResponse("hello!"); |
| 4464 | } |
| 4465 | |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4466 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) { |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 4467 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| 4468 | "PROXY myproxy:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4469 | |
| 4470 | // Since we are using a proxy, the QUIC job will not succeed. |
| 4471 | MockWrite http_writes[] = { |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4472 | MockWrite(SYNCHRONOUS, 0, "GET http://mail.example.org/ HTTP/1.1\r\n"), |
| 4473 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4474 | MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n")}; |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4475 | |
| 4476 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4477 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 4478 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4479 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4480 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4481 | StaticSocketDataProvider http_data(http_reads, http_writes); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4482 | socket_factory_.AddSocketDataProvider(&http_data); |
| 4483 | |
| 4484 | // In order for a new QUIC session to be established via alternate-protocol |
| 4485 | // without racing an HTTP connection, we need the host resolution to happen |
| 4486 | // synchronously. |
| 4487 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4488 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4489 | ""); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4490 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4491 | request_.url = GURL("http://mail.example.org/"); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4492 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4493 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4494 | SendRequestAndExpectHttpResponse("hello world"); |
| 4495 | } |
| 4496 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4497 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4498 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4499 | int packet_num = 1; |
| 4500 | if (VersionUsesQpack(version_.transport_version)) { |
| 4501 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4502 | ConstructInitialSettingsPacket(packet_num++)); |
| 4503 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4504 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4505 | SYNCHRONOUS, |
| 4506 | ConstructClientRequestHeadersPacket( |
| 4507 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4508 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4509 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4510 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4511 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4512 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4513 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4514 | mock_quic_data.AddRead( |
| 4515 | ASYNC, ConstructServerDataPacket( |
| 4516 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4517 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4518 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4519 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4520 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 4521 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4522 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4523 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4524 | // the alternate-protocol job will "win". |
| 4525 | AddHangingNonAlternateProtocolSocketData(); |
| 4526 | |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4527 | // In order for a new QUIC session to be established via alternate-protocol |
| 4528 | // without racing an HTTP connection, we need the host resolution to happen |
| 4529 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 4530 | // connection to the the server, in this test we require confirmation |
| 4531 | // before encrypting so the HTTP job will still start. |
| 4532 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4533 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4534 | ""); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4535 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4536 | CreateSession(); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4537 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4538 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4539 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4540 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4541 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 4542 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4543 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4544 | |
| 4545 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4546 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4547 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 4548 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4549 | CheckWasQuicResponse(&trans); |
| 4550 | CheckResponseData(&trans, "hello!"); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4551 | } |
| 4552 | |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4553 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithTooEarlyResponse) { |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4554 | uint64_t packet_number = 1; |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4555 | MockQuicData mock_quic_data(version_); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 4556 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4557 | mock_quic_data.AddWrite( |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4558 | SYNCHRONOUS, |
| 4559 | ConstructClientRequestHeadersPacket( |
| 4560 | packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4561 | true, GetRequestHeaders("GET", "https", "/"))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4562 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4563 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4564 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4565 | GetResponseHeaders("425 TOO_EARLY"))); |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4566 | mock_quic_data.AddWrite( |
| 4567 | SYNCHRONOUS, |
| 4568 | ConstructClientAckAndRstPacket( |
| 4569 | packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 4570 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4571 | |
| 4572 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| 4573 | |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4574 | mock_quic_data.AddWrite( |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4575 | SYNCHRONOUS, |
| 4576 | ConstructClientRequestHeadersPacket( |
| 4577 | packet_number++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 4578 | true, GetRequestHeaders("GET", "https", "/"), |
| 4579 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4580 | mock_quic_data.AddRead( |
| 4581 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4582 | 2, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4583 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 4584 | std::string header = ConstructDataHeader(6); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4585 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4586 | ASYNC, ConstructServerDataPacket( |
| 4587 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 4588 | header + "hello!")); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4589 | mock_quic_data.AddWrite( |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4590 | SYNCHRONOUS, |
| 4591 | ConstructClientAckAndConnectionClosePacket(packet_number++, 3, 1, 1)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4592 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4593 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4594 | |
| 4595 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4596 | |
| 4597 | // In order for a new QUIC session to be established via alternate-protocol |
| 4598 | // without racing an HTTP connection, we need the host resolution to happen |
| 4599 | // synchronously. |
| 4600 | host_resolver_.set_synchronous_mode(true); |
| 4601 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 4602 | ""); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4603 | |
| 4604 | AddHangingNonAlternateProtocolSocketData(); |
| 4605 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4606 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 4607 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4608 | session_->quic_stream_factory(), |
| 4609 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4610 | &clock_)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4611 | |
| 4612 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 4613 | TestCompletionCallback callback; |
| 4614 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 4615 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 4616 | |
| 4617 | // Confirm the handshake after the 425 Too Early. |
| 4618 | base::RunLoop().RunUntilIdle(); |
| 4619 | |
| 4620 | // The handshake hasn't been confirmed yet, so the retry should not have |
| 4621 | // succeeded. |
| 4622 | EXPECT_FALSE(callback.have_result()); |
| 4623 | |
| 4624 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 4625 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 4626 | |
| 4627 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 4628 | CheckWasQuicResponse(&trans); |
| 4629 | CheckResponseData(&trans, "hello!"); |
| 4630 | } |
| 4631 | |
| 4632 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithMultipleTooEarlyResponse) { |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4633 | uint64_t packet_number = 1; |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4634 | MockQuicData mock_quic_data(version_); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 4635 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4636 | mock_quic_data.AddWrite( |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4637 | SYNCHRONOUS, |
| 4638 | ConstructClientRequestHeadersPacket( |
| 4639 | packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4640 | true, GetRequestHeaders("GET", "https", "/"))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4641 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4642 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4643 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4644 | GetResponseHeaders("425 TOO_EARLY"))); |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4645 | mock_quic_data.AddWrite( |
| 4646 | SYNCHRONOUS, |
| 4647 | ConstructClientAckAndRstPacket( |
| 4648 | packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 4649 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4650 | |
| 4651 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| 4652 | |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4653 | mock_quic_data.AddWrite( |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4654 | SYNCHRONOUS, |
| 4655 | ConstructClientRequestHeadersPacket( |
| 4656 | packet_number++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 4657 | true, GetRequestHeaders("GET", "https", "/"), |
| 4658 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4659 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 4660 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4661 | 2, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
| 4662 | GetResponseHeaders("425 TOO_EARLY"))); |
Ryan Hamilton | 3cc2c15 | 2019-07-09 19:36:01 | [diff] [blame] | 4663 | mock_quic_data.AddWrite( |
| 4664 | SYNCHRONOUS, |
| 4665 | ConstructClientAckAndRstPacket( |
| 4666 | packet_number++, GetNthClientInitiatedBidirectionalStreamId(1), |
| 4667 | quic::QUIC_STREAM_CANCELLED, 2, 1, 1)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4668 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4669 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4670 | |
| 4671 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4672 | |
| 4673 | // In order for a new QUIC session to be established via alternate-protocol |
| 4674 | // without racing an HTTP connection, we need the host resolution to happen |
| 4675 | // synchronously. |
| 4676 | host_resolver_.set_synchronous_mode(true); |
| 4677 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 4678 | ""); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4679 | |
| 4680 | AddHangingNonAlternateProtocolSocketData(); |
| 4681 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4682 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 4683 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4684 | session_->quic_stream_factory(), |
| 4685 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4686 | &clock_)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4687 | |
| 4688 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 4689 | TestCompletionCallback callback; |
| 4690 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 4691 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 4692 | |
| 4693 | // Confirm the handshake after the 425 Too Early. |
| 4694 | base::RunLoop().RunUntilIdle(); |
| 4695 | |
| 4696 | // The handshake hasn't been confirmed yet, so the retry should not have |
| 4697 | // succeeded. |
| 4698 | EXPECT_FALSE(callback.have_result()); |
| 4699 | |
| 4700 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 4701 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 4702 | |
| 4703 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 4704 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
| 4705 | ASSERT_TRUE(response != nullptr); |
| 4706 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 4707 | EXPECT_EQ("HTTP/1.1 425 TOO_EARLY", response->headers->GetStatusLine()); |
| 4708 | EXPECT_TRUE(response->was_fetched_via_spdy); |
| 4709 | EXPECT_TRUE(response->was_alpn_negotiated); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 4710 | EXPECT_EQ( |
| 4711 | QuicHttpStream::ConnectionInfoFromQuicVersion(version_.transport_version), |
| 4712 | response->connection_info); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4713 | } |
| 4714 | |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4715 | TEST_P(QuicNetworkTransactionTest, |
| 4716 | LogGranularQuicErrorCodeOnQuicProtocolErrorLocal) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 4717 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4718 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4719 | int packet_num = 1; |
| 4720 | if (VersionUsesQpack(version_.transport_version)) { |
| 4721 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4722 | ConstructInitialSettingsPacket(packet_num++)); |
| 4723 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4724 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4725 | SYNCHRONOUS, |
| 4726 | ConstructClientRequestHeadersPacket( |
| 4727 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4728 | true, GetRequestHeaders("GET", "https", "/"))); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4729 | // Read a close connection packet with |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4730 | // quic::QuicErrorCode: quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED from the peer. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4731 | mock_quic_data.AddRead(ASYNC, ConstructServerConnectionClosePacket(1)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4732 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4733 | |
| 4734 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4735 | // the alternate-protocol job will "win". |
| 4736 | AddHangingNonAlternateProtocolSocketData(); |
| 4737 | |
| 4738 | // In order for a new QUIC session to be established via alternate-protocol |
| 4739 | // without racing an HTTP connection, we need the host resolution to happen |
| 4740 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 4741 | // connection to the the server, in this test we require confirmation |
| 4742 | // before encrypting so the HTTP job will still start. |
| 4743 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4744 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4745 | ""); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4746 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4747 | CreateSession(); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4748 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4749 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4750 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4751 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4752 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 4753 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4754 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4755 | |
| 4756 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4757 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4758 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4759 | |
| 4760 | NetErrorDetails details; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4761 | EXPECT_EQ(quic::QUIC_NO_ERROR, details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4762 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4763 | trans.PopulateNetErrorDetails(&details); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4764 | // Verify the error code logged is what sent by the peer. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4765 | EXPECT_EQ(quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, |
| 4766 | details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4767 | } |
| 4768 | |
| 4769 | TEST_P(QuicNetworkTransactionTest, |
| 4770 | LogGranularQuicErrorCodeOnQuicProtocolErrorRemote) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 4771 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4772 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4773 | int packet_num = 1; |
| 4774 | if (VersionUsesQpack(version_.transport_version)) { |
| 4775 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4776 | ConstructInitialSettingsPacket(packet_num++)); |
| 4777 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4778 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4779 | SYNCHRONOUS, |
| 4780 | ConstructClientRequestHeadersPacket( |
| 4781 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4782 | true, GetRequestHeaders("GET", "https", "/"))); |
zhongyi | f28b4a3 | 2016-04-25 21:35:21 | [diff] [blame] | 4783 | // Peer sending data from an non-existing stream causes this end to raise |
| 4784 | // error and close connection. |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4785 | mock_quic_data.AddRead( |
| 4786 | ASYNC, ConstructServerRstPacket( |
| 4787 | 1, false, GetNthClientInitiatedBidirectionalStreamId(47), |
| 4788 | quic::QUIC_STREAM_LAST_ERROR)); |
zhongyi | f28b4a3 | 2016-04-25 21:35:21 | [diff] [blame] | 4789 | std::string quic_error_details = "Data for nonexistent stream"; |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4790 | mock_quic_data.AddWrite( |
| 4791 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket( |
| 4792 | packet_num++, quic::QuicTime::Delta::Zero(), 1, 1, 1, |
| 4793 | quic::QUIC_INVALID_STREAM_ID, quic_error_details, |
| 4794 | quic::IETF_RST_STREAM)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4795 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4796 | |
| 4797 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4798 | // the alternate-protocol job will "win". |
| 4799 | AddHangingNonAlternateProtocolSocketData(); |
| 4800 | |
| 4801 | // In order for a new QUIC session to be established via alternate-protocol |
| 4802 | // without racing an HTTP connection, we need the host resolution to happen |
| 4803 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 4804 | // connection to the the server, in this test we require confirmation |
| 4805 | // before encrypting so the HTTP job will still start. |
| 4806 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4807 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4808 | ""); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4809 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4810 | CreateSession(); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4811 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4812 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4813 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4814 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4815 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 4816 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4817 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4818 | |
| 4819 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4820 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4821 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4822 | NetErrorDetails details; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4823 | EXPECT_EQ(quic::QUIC_NO_ERROR, details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4824 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4825 | trans.PopulateNetErrorDetails(&details); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4826 | EXPECT_EQ(quic::QUIC_INVALID_STREAM_ID, details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 4827 | } |
| 4828 | |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4829 | TEST_P(QuicNetworkTransactionTest, RstSteamErrorHandling) { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4830 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4831 | int packet_num = 1; |
| 4832 | if (VersionUsesQpack(version_.transport_version)) { |
| 4833 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4834 | ConstructInitialSettingsPacket(packet_num++)); |
| 4835 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4836 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4837 | SYNCHRONOUS, |
| 4838 | ConstructClientRequestHeadersPacket( |
| 4839 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4840 | true, GetRequestHeaders("GET", "https", "/"))); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4841 | // Read the response headers, then a RST_STREAM frame. |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4842 | mock_quic_data.AddRead( |
| 4843 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4844 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 4845 | GetResponseHeaders("200 OK"))); |
| 4846 | mock_quic_data.AddRead( |
| 4847 | ASYNC, ConstructServerRstPacket( |
| 4848 | 2, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 4849 | quic::QUIC_STREAM_CANCELLED)); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4850 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4851 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4852 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
| 4853 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4854 | |
| 4855 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4856 | // the alternate-protocol job will "win". |
| 4857 | AddHangingNonAlternateProtocolSocketData(); |
| 4858 | |
| 4859 | // In order for a new QUIC session to be established via alternate-protocol |
| 4860 | // without racing an HTTP connection, we need the host resolution to happen |
| 4861 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 4862 | // connection to the the server, in this test we require confirmation |
| 4863 | // before encrypting so the HTTP job will still start. |
| 4864 | host_resolver_.set_synchronous_mode(true); |
| 4865 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 4866 | ""); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4867 | |
| 4868 | CreateSession(); |
| 4869 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4870 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4871 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4872 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4873 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 4874 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4875 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4876 | |
| 4877 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4878 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4879 | // Read the headers. |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4880 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4881 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4882 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4883 | ASSERT_TRUE(response != nullptr); |
| 4884 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 4885 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 4886 | EXPECT_TRUE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 4887 | EXPECT_TRUE(response->was_alpn_negotiated); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 4888 | EXPECT_EQ( |
| 4889 | QuicHttpStream::ConnectionInfoFromQuicVersion(version_.transport_version), |
| 4890 | response->connection_info); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4891 | |
| 4892 | std::string response_data; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4893 | ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, ReadTransaction(&trans, &response_data)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4894 | } |
| 4895 | |
| 4896 | TEST_P(QuicNetworkTransactionTest, RstSteamBeforeHeaders) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 4897 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 4898 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4899 | int packet_num = 1; |
| 4900 | if (VersionUsesQpack(version_.transport_version)) { |
| 4901 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4902 | ConstructInitialSettingsPacket(packet_num++)); |
| 4903 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4904 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 4905 | SYNCHRONOUS, |
| 4906 | ConstructClientRequestHeadersPacket( |
| 4907 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 4908 | true, GetRequestHeaders("GET", "https", "/"))); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 4909 | mock_quic_data.AddRead( |
| 4910 | ASYNC, ConstructServerRstPacket( |
| 4911 | 1, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 4912 | quic::QUIC_STREAM_CANCELLED)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4913 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
| 4914 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4915 | |
| 4916 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4917 | // the alternate-protocol job will "win". |
| 4918 | AddHangingNonAlternateProtocolSocketData(); |
| 4919 | |
| 4920 | // In order for a new QUIC session to be established via alternate-protocol |
| 4921 | // without racing an HTTP connection, we need the host resolution to happen |
| 4922 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 4923 | // connection to the the server, in this test we require confirmation |
| 4924 | // before encrypting so the HTTP job will still start. |
| 4925 | host_resolver_.set_synchronous_mode(true); |
| 4926 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 4927 | ""); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4928 | |
| 4929 | CreateSession(); |
| 4930 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4931 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4932 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4933 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4934 | TestCompletionCallback callback; |
Eric Orth | 608a299 | 2019-02-20 19:29:36 | [diff] [blame] | 4935 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4936 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4937 | |
| 4938 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4939 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4940 | // Read the headers. |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4941 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 4942 | } |
| 4943 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4944 | TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) { |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4945 | // Alternate-protocol job |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4946 | std::unique_ptr<quic::QuicEncryptedPacket> close( |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4947 | ConstructServerConnectionClosePacket(1)); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4948 | MockRead quic_reads[] = { |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 4949 | MockRead(ASYNC, close->data(), close->length()), |
| 4950 | MockRead(ASYNC, ERR_IO_PENDING), // No more data to read |
| 4951 | MockRead(ASYNC, OK), // EOF |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4952 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4953 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4954 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 4955 | |
| 4956 | // Main job which will succeed even though the alternate job fails. |
| 4957 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 4958 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 4959 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4960 | MockRead(ASYNC, OK)}; |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4961 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4962 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4963 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4964 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4965 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4966 | CreateSession(); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 4967 | AddQuicAlternateProtocolMapping( |
| 4968 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 4969 | SendRequestAndExpectHttpResponse("hello from http"); |
| 4970 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 4971 | } |
| 4972 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4973 | TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) { |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4974 | // Alternate-protocol job |
| 4975 | MockRead quic_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 4976 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4977 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4978 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4979 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 4980 | |
| 4981 | // Main job which will succeed even though the alternate job fails. |
| 4982 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 4983 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 4984 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4985 | MockRead(ASYNC, OK)}; |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4986 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4987 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4988 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4989 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4990 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4991 | CreateSession(); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4992 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4993 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 4994 | SendRequestAndExpectHttpResponse("hello from http"); |
| 4995 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 4996 | } |
| 4997 | |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 4998 | TEST_P(QuicNetworkTransactionTest, NoBrokenAlternateProtocolIfTcpFails) { |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 4999 | // Alternate-protocol job will fail when the session attempts to read. |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5000 | MockRead quic_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5001 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5002 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5003 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5004 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5005 | |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 5006 | // Main job will also fail. |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5007 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5008 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5009 | }; |
| 5010 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5011 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5012 | http_data.set_connect_data(MockConnect(ASYNC, ERR_SOCKET_NOT_CONNECTED)); |
| 5013 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5014 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5015 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5016 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5017 | CreateSession(); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5018 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5019 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5020 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5021 | TestCompletionCallback callback; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5022 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5023 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5024 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_SOCKET_NOT_CONNECTED)); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5025 | ExpectQuicAlternateProtocolMapping(); |
| 5026 | } |
| 5027 | |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5028 | TEST_P(QuicNetworkTransactionTest, DelayTCPOnStartWithQuicSupportOnSameIP) { |
| 5029 | // Tests that TCP job is delayed and QUIC job does not require confirmation |
| 5030 | // if QUIC was recently supported on the same IP on start. |
| 5031 | |
| 5032 | // Set QUIC support on the last IP address, which is same with the local IP |
| 5033 | // address. Require confirmation mode will be turned off immediately when |
| 5034 | // local IP address is sorted out after we configure the UDP socket. |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 5035 | http_server_properties_->SetSupportsQuic(true, IPAddress(192, 0, 2, 33)); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5036 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5037 | MockQuicData mock_quic_data(version_); |
Michael Warres | 167db3e | 2019-03-01 21:38:03 | [diff] [blame] | 5038 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5039 | mock_quic_data.AddWrite( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5040 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 5041 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 5042 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5043 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5044 | ASYNC, ConstructServerResponseHeadersPacket( |
| 5045 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 5046 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5047 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5048 | mock_quic_data.AddRead( |
| 5049 | ASYNC, ConstructServerDataPacket( |
| 5050 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5051 | header + "hello!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5052 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 2, 1, 1)); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5053 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 5054 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 5055 | |
| 5056 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5057 | // No HTTP data is mocked as TCP job never starts in this case. |
| 5058 | |
| 5059 | CreateSession(); |
| 5060 | // QuicStreamFactory by default requires confirmation on construction. |
| 5061 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 5062 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5063 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5064 | |
| 5065 | // Stall host resolution so that QUIC job will not succeed synchronously. |
| 5066 | // Socket will not be configured immediately and QUIC support is not sorted |
| 5067 | // out, TCP job will still be delayed as server properties indicates QUIC |
| 5068 | // support on last IP address. |
| 5069 | host_resolver_.set_synchronous_mode(false); |
| 5070 | |
| 5071 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5072 | TestCompletionCallback callback; |
| 5073 | EXPECT_THAT(trans.Start(&request_, callback.callback(), net_log_.bound()), |
| 5074 | IsError(ERR_IO_PENDING)); |
| 5075 | // Complete host resolution in next message loop so that QUIC job could |
| 5076 | // proceed. |
| 5077 | base::RunLoop().RunUntilIdle(); |
| 5078 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 5079 | |
| 5080 | CheckWasQuicResponse(&trans); |
| 5081 | CheckResponseData(&trans, "hello!"); |
| 5082 | } |
| 5083 | |
| 5084 | TEST_P(QuicNetworkTransactionTest, |
| 5085 | DelayTCPOnStartWithQuicSupportOnDifferentIP) { |
| 5086 | // Tests that TCP job is delayed and QUIC job requires confirmation if QUIC |
| 5087 | // was recently supported on a different IP address on start. |
| 5088 | |
| 5089 | // Set QUIC support on the last IP address, which is different with the local |
| 5090 | // IP address. Require confirmation mode will remain when local IP address is |
| 5091 | // sorted out after we configure the UDP socket. |
Matt Menke | 3233d8f2 | 2019-08-20 21:01:49 | [diff] [blame] | 5092 | http_server_properties_->SetSupportsQuic(true, IPAddress(1, 2, 3, 4)); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5093 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5094 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5095 | int packet_num = 1; |
| 5096 | if (VersionUsesQpack(version_.transport_version)) { |
| 5097 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5098 | ConstructInitialSettingsPacket(packet_num++)); |
| 5099 | } |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5100 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5101 | SYNCHRONOUS, |
| 5102 | ConstructClientRequestHeadersPacket( |
| 5103 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 5104 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5105 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5106 | ASYNC, ConstructServerResponseHeadersPacket( |
| 5107 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 5108 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5109 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5110 | mock_quic_data.AddRead( |
| 5111 | ASYNC, ConstructServerDataPacket( |
| 5112 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5113 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5114 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5115 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5116 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 5117 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5118 | // No HTTP data is mocked as TCP job will be delayed and never starts. |
| 5119 | |
| 5120 | CreateSession(); |
| 5121 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5122 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5123 | |
| 5124 | // Stall host resolution so that QUIC job could not proceed and unblocks TCP. |
| 5125 | // Socket will not be configured immediately and QUIC support is not sorted |
| 5126 | // out, TCP job will still be delayed as server properties indicates QUIC |
| 5127 | // support on last IP address. |
| 5128 | host_resolver_.set_synchronous_mode(false); |
| 5129 | |
| 5130 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5131 | TestCompletionCallback callback; |
| 5132 | EXPECT_THAT(trans.Start(&request_, callback.callback(), net_log_.bound()), |
| 5133 | IsError(ERR_IO_PENDING)); |
| 5134 | |
| 5135 | // Complete host resolution in next message loop so that QUIC job could |
| 5136 | // proceed. |
| 5137 | base::RunLoop().RunUntilIdle(); |
| 5138 | // Explicitly confirm the handshake so that QUIC job could succeed. |
| 5139 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5140 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5141 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 5142 | |
| 5143 | CheckWasQuicResponse(&trans); |
| 5144 | CheckResponseData(&trans, "hello!"); |
| 5145 | } |
| 5146 | |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5147 | TEST_P(QuicNetworkTransactionTest, NetErrorDetailsSetBeforeHandshake) { |
| 5148 | // Test that NetErrorDetails is correctly populated, even if the |
| 5149 | // handshake has not yet been confirmed and no stream has been created. |
| 5150 | |
| 5151 | // QUIC job will pause. When resumed, it will fail. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5152 | MockQuicData mock_quic_data(version_); |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5153 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 5154 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED); |
| 5155 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5156 | |
| 5157 | // Main job will also fail. |
| 5158 | MockRead http_reads[] = { |
| 5159 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
| 5160 | }; |
| 5161 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5162 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5163 | http_data.set_connect_data(MockConnect(ASYNC, ERR_SOCKET_NOT_CONNECTED)); |
| 5164 | socket_factory_.AddSocketDataProvider(&http_data); |
| 5165 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 5166 | |
| 5167 | AddHangingNonAlternateProtocolSocketData(); |
| 5168 | CreateSession(); |
| 5169 | // Require handshake confirmation to ensure that no QUIC streams are |
| 5170 | // created, and to ensure that the TCP job does not wait for the QUIC |
| 5171 | // job to fail before it starts. |
| 5172 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 5173 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5174 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5175 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5176 | TestCompletionCallback callback; |
| 5177 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5178 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5179 | // Allow the TCP job to fail. |
| 5180 | base::RunLoop().RunUntilIdle(); |
| 5181 | // Now let the QUIC job fail. |
| 5182 | mock_quic_data.Resume(); |
| 5183 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 5184 | ExpectQuicAlternateProtocolMapping(); |
| 5185 | NetErrorDetails details; |
| 5186 | trans.PopulateNetErrorDetails(&details); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5187 | EXPECT_EQ(quic::QUIC_PACKET_READ_ERROR, details.quic_connection_error); |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5188 | } |
| 5189 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 5190 | TEST_P(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) { |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5191 | // Alternate-protocol job |
| 5192 | MockRead quic_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5193 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5194 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5195 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5196 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5197 | |
[email protected] | c92c1b5 | 2014-05-31 04:16:06 | [diff] [blame] | 5198 | // Second Alternate-protocol job which will race with the TCP job. |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5199 | StaticSocketDataProvider quic_data2(quic_reads, base::span<MockWrite>()); |
[email protected] | c92c1b5 | 2014-05-31 04:16:06 | [diff] [blame] | 5200 | socket_factory_.AddSocketDataProvider(&quic_data2); |
| 5201 | |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5202 | // Final job that will proceed when the QUIC job fails. |
| 5203 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5204 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5205 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5206 | MockRead(ASYNC, OK)}; |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5207 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5208 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5209 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5210 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5211 | |
rtenneti | afccbc06 | 2016-05-16 18:21:14 | [diff] [blame] | 5212 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5213 | CreateSession(); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5214 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5215 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5216 | |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5217 | SendRequestAndExpectHttpResponse("hello from http"); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5218 | |
| 5219 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5220 | |
rch | 37de576c | 2015-05-17 20:28:17 | [diff] [blame] | 5221 | EXPECT_TRUE(quic_data.AllReadDataConsumed()); |
| 5222 | EXPECT_TRUE(quic_data.AllWriteDataConsumed()); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5223 | } |
| 5224 | |
[email protected] | 93b3177 | 2014-06-19 08:03:35 | [diff] [blame] | 5225 | TEST_P(QuicNetworkTransactionTest, DISABLED_HangingZeroRttFallback) { |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5226 | // Alternate-protocol job |
| 5227 | MockRead quic_reads[] = { |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 5228 | MockRead(SYNCHRONOUS, ERR_IO_PENDING), |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5229 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5230 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5231 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5232 | |
| 5233 | // Main job that will proceed when the QUIC job fails. |
| 5234 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5235 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5236 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5237 | MockRead(ASYNC, OK)}; |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5238 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5239 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5240 | socket_factory_.AddSocketDataProvider(&http_data); |
| 5241 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5242 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5243 | CreateSession(); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5244 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5245 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5246 | |
| 5247 | SendRequestAndExpectHttpResponse("hello from http"); |
| 5248 | } |
| 5249 | |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 5250 | TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolOnConnectFailure) { |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5251 | // Alternate-protocol job will fail before creating a QUIC session. |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5252 | StaticSocketDataProvider quic_data; |
tbansal | 6b52748 | 2017-01-27 19:10:49 | [diff] [blame] | 5253 | quic_data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5254 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5255 | |
| 5256 | // Main job which will succeed even though the alternate job fails. |
| 5257 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5258 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5259 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5260 | MockRead(ASYNC, OK)}; |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5261 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5262 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5263 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5264 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5265 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5266 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5267 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5268 | SendRequestAndExpectHttpResponse("hello from http"); |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 5269 | |
| 5270 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5271 | } |
| 5272 | |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5273 | TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5274 | MockQuicData mock_quic_data(version_); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 5275 | mock_quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDummyCHLOPacket(1)); |
| 5276 | mock_quic_data.AddRead(ASYNC, ConstructServerConnectionClosePacket(1)); |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 5277 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5278 | |
| 5279 | // When the QUIC connection fails, we will try the request again over HTTP. |
| 5280 | MockRead http_reads[] = { |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 5281 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5282 | MockRead("hello world"), |
| 5283 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5284 | MockRead(ASYNC, OK)}; |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5285 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5286 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5287 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5288 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5289 | |
| 5290 | // In order for a new QUIC session to be established via alternate-protocol |
| 5291 | // without racing an HTTP connection, we need the host resolution to happen |
| 5292 | // synchronously. |
| 5293 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 5294 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5295 | ""); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5296 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5297 | CreateSession(); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 5298 | // TODO(rch): Check if we need a 0RTT version of ConnectionCloseDuringConnect |
| 5299 | AddQuicAlternateProtocolMapping( |
| 5300 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5301 | SendRequestAndExpectHttpResponse("hello world"); |
| 5302 | } |
| 5303 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5304 | // For an alternative proxy that supports QUIC, test that the request is |
| 5305 | // successfully fetched by the main job when the alternate proxy job encounters |
| 5306 | // an error. |
| 5307 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxySocketNotConnected) { |
| 5308 | TestAlternativeProxy(ERR_SOCKET_NOT_CONNECTED); |
| 5309 | } |
| 5310 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyConnectionFailed) { |
| 5311 | TestAlternativeProxy(ERR_CONNECTION_FAILED); |
| 5312 | } |
| 5313 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyConnectionTimedOut) { |
| 5314 | TestAlternativeProxy(ERR_CONNECTION_TIMED_OUT); |
| 5315 | } |
| 5316 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyConnectionRefused) { |
| 5317 | TestAlternativeProxy(ERR_CONNECTION_REFUSED); |
| 5318 | } |
| 5319 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyQuicHandshakeFailed) { |
| 5320 | TestAlternativeProxy(ERR_QUIC_HANDSHAKE_FAILED); |
| 5321 | } |
| 5322 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyQuicProtocolError) { |
| 5323 | TestAlternativeProxy(ERR_QUIC_PROTOCOL_ERROR); |
| 5324 | } |
| 5325 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyIOPending) { |
| 5326 | TestAlternativeProxy(ERR_IO_PENDING); |
| 5327 | } |
| 5328 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyAddressUnreachable) { |
| 5329 | TestAlternativeProxy(ERR_ADDRESS_UNREACHABLE); |
| 5330 | } |
| 5331 | |
| 5332 | TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnectProxy) { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5333 | MockQuicData mock_quic_data(version_); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 5334 | mock_quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDummyCHLOPacket(1)); |
| 5335 | mock_quic_data.AddRead(ASYNC, ConstructServerConnectionClosePacket(1)); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5336 | mock_quic_data.AddWrite( |
| 5337 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 5338 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 5339 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5340 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 1, 1, 1)); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5341 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5342 | |
| 5343 | // When the QUIC connection fails, we will try the request again over HTTP. |
| 5344 | MockRead http_reads[] = { |
| 5345 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 5346 | MockRead("hello world"), |
| 5347 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5348 | MockRead(ASYNC, OK)}; |
| 5349 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5350 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5351 | socket_factory_.AddSocketDataProvider(&http_data); |
| 5352 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 5353 | |
| 5354 | TestProxyDelegate test_proxy_delegate; |
| 5355 | const HostPortPair host_port_pair("myproxy.org", 443); |
| 5356 | test_proxy_delegate.set_alternative_proxy_server( |
| 5357 | ProxyServer::FromPacString("QUIC myproxy.org:443")); |
| 5358 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 5359 | |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 5360 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| 5361 | "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 5362 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5363 | request_.url = GURL("http://mail.example.org/"); |
| 5364 | |
| 5365 | // In order for a new QUIC session to be established via alternate-protocol |
| 5366 | // without racing an HTTP connection, we need the host resolution to happen |
| 5367 | // synchronously. |
| 5368 | host_resolver_.set_synchronous_mode(true); |
| 5369 | host_resolver_.rules()->AddIPLiteralRule("myproxy.org", "192.168.0.1", ""); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5370 | |
| 5371 | CreateSession(); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 5372 | crypto_client_stream_factory_.set_handshake_mode( |
| 5373 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5374 | SendRequestAndExpectHttpResponseFromProxy("hello world", true, 443); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 5375 | EXPECT_THAT(session_->proxy_resolution_service()->proxy_retry_info(), |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 5376 | ElementsAre(Key("quic://myproxy.org:443"))); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5377 | } |
| 5378 | |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5379 | TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 5380 | client_maker_.set_hostname("www.example.org"); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 5381 | EXPECT_FALSE( |
| 5382 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5383 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5384 | int packet_num = 1; |
| 5385 | if (VersionUsesQpack(version_.transport_version)) { |
| 5386 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5387 | ConstructInitialSettingsPacket(packet_num++)); |
| 5388 | } |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 5389 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5390 | SYNCHRONOUS, |
| 5391 | ConstructClientRequestHeadersPacket( |
| 5392 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 5393 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5394 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5395 | ASYNC, ConstructServerResponseHeadersPacket( |
| 5396 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 5397 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5398 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5399 | mock_quic_data.AddRead( |
| 5400 | ASYNC, ConstructServerDataPacket( |
| 5401 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5402 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5403 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5404 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 5405 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5406 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5407 | |
bnc | b07c0553 | 2015-05-14 19:07:20 | [diff] [blame] | 5408 | request_.url = GURL("https://www.example.org:443"); |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5409 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5410 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5411 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5412 | SendRequestAndExpectQuicResponse("hello!"); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 5413 | EXPECT_TRUE( |
| 5414 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5415 | } |
| 5416 | |
zhongyi | 363c91c | 2017-03-23 23:16:08 | [diff] [blame] | 5417 | // TODO(zhongyi): disabled this broken test as it was not testing the correct |
| 5418 | // code path. Need a fix to re-enable this test, tracking at crbug.com/704596. |
| 5419 | TEST_P(QuicNetworkTransactionTest, |
| 5420 | DISABLED_QuicUploadToAlternativeProxyServer) { |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 5421 | base::HistogramTester histogram_tester; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 5422 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 5423 | "HTTPS mail.example.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5424 | |
| 5425 | TestProxyDelegate test_proxy_delegate; |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5426 | |
| 5427 | test_proxy_delegate.set_alternative_proxy_server( |
| 5428 | ProxyServer::FromPacString("QUIC mail.example.org:443")); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 5429 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5430 | |
| 5431 | request_.url = GURL("http://mail.example.org/"); |
| 5432 | |
| 5433 | MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
| 5434 | MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5435 | SequencedSocketData socket_data(reads, writes); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5436 | socket_factory_.AddSocketDataProvider(&socket_data); |
| 5437 | |
| 5438 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5439 | // the alternate-protocol job will "win". |
| 5440 | AddHangingNonAlternateProtocolSocketData(); |
| 5441 | |
| 5442 | CreateSession(); |
| 5443 | request_.method = "POST"; |
| 5444 | ChunkedUploadDataStream upload_data(0); |
| 5445 | upload_data.AppendData("1", 1, true); |
| 5446 | |
| 5447 | request_.upload_data_stream = &upload_data; |
| 5448 | |
| 5449 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5450 | TestCompletionCallback callback; |
| 5451 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5452 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5453 | EXPECT_NE(OK, callback.WaitForResult()); |
| 5454 | |
| 5455 | // Verify that the alternative proxy server is not marked as broken. |
| 5456 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 5457 | |
| 5458 | // Verify that the proxy server is not marked as broken. |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 5459 | EXPECT_TRUE(session_->proxy_resolution_service()->proxy_retry_info().empty()); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 5460 | |
| 5461 | histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage", |
| 5462 | 1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */, |
| 5463 | 1); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5464 | } |
| 5465 | |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5466 | TEST_P(QuicNetworkTransactionTest, QuicUpload) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5467 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 5468 | HostPortPair::FromString("mail.example.org:443")); |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5469 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5470 | MockQuicData mock_quic_data(version_); |
| 5471 | if (!VersionUsesQpack(version_.transport_version)) |
| 5472 | mock_quic_data.AddRead(SYNCHRONOUS, OK); |
| 5473 | else |
| 5474 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 5475 | mock_quic_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
| 5476 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5477 | |
| 5478 | /*MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
| 5479 | //MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)}; |
| 5480 | MockWrite writes[] = {}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5481 | SequencedSocketData socket_data(reads, writes); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5482 | socket_factory_.AddSocketDataProvider(&socket_data);*/ |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5483 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5484 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5485 | // the alternate-protocol job will "win". |
| 5486 | AddHangingNonAlternateProtocolSocketData(); |
| 5487 | |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5488 | CreateSession(); |
| 5489 | request_.method = "POST"; |
| 5490 | ChunkedUploadDataStream upload_data(0); |
| 5491 | upload_data.AppendData("1", 1, true); |
| 5492 | |
| 5493 | request_.upload_data_stream = &upload_data; |
| 5494 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5495 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5496 | TestCompletionCallback callback; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5497 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5498 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5499 | EXPECT_NE(OK, callback.WaitForResult()); |
| 5500 | } |
| 5501 | |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5502 | TEST_P(QuicNetworkTransactionTest, QuicUploadWriteError) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5503 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5504 | ScopedMockNetworkChangeNotifier network_change_notifier; |
| 5505 | MockNetworkChangeNotifier* mock_ncn = |
| 5506 | network_change_notifier.mock_network_change_notifier(); |
| 5507 | mock_ncn->ForceNetworkHandlesSupported(); |
| 5508 | mock_ncn->SetConnectedNetworksList( |
| 5509 | {kDefaultNetworkForTests, kNewNetworkForTests}); |
| 5510 | |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5511 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5512 | HostPortPair::FromString("mail.example.org:443")); |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5513 | session_params_.quic_params.migrate_sessions_on_network_change_v2 = true; |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5514 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5515 | MockQuicData socket_data(version_); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5516 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5517 | int packet_num = 1; |
| 5518 | if (VersionUsesQpack(version_.transport_version)) { |
| 5519 | socket_data.AddWrite(SYNCHRONOUS, |
| 5520 | ConstructInitialSettingsPacket(packet_num++)); |
| 5521 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5522 | socket_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5523 | SYNCHRONOUS, |
| 5524 | ConstructClientRequestHeadersPacket( |
| 5525 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 5526 | false, GetRequestHeaders("POST", "https", "/"))); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5527 | socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
| 5528 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5529 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5530 | MockQuicData socket_data2(version_); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5531 | socket_data2.AddConnect(SYNCHRONOUS, ERR_ADDRESS_INVALID); |
| 5532 | socket_data2.AddSocketDataToFactory(&socket_factory_); |
| 5533 | |
| 5534 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5535 | // the alternate-protocol job will "win". |
| 5536 | AddHangingNonAlternateProtocolSocketData(); |
| 5537 | |
| 5538 | CreateSession(); |
| 5539 | request_.method = "POST"; |
| 5540 | ChunkedUploadDataStream upload_data(0); |
| 5541 | |
| 5542 | request_.upload_data_stream = &upload_data; |
| 5543 | |
rdsmith | 1d343be5 | 2016-10-21 20:37:50 | [diff] [blame] | 5544 | std::unique_ptr<HttpNetworkTransaction> trans( |
| 5545 | new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get())); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5546 | TestCompletionCallback callback; |
rdsmith | 1d343be5 | 2016-10-21 20:37:50 | [diff] [blame] | 5547 | int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5548 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5549 | |
| 5550 | base::RunLoop().RunUntilIdle(); |
| 5551 | upload_data.AppendData("1", 1, true); |
| 5552 | base::RunLoop().RunUntilIdle(); |
| 5553 | |
| 5554 | EXPECT_NE(OK, callback.WaitForResult()); |
rdsmith | 1d343be5 | 2016-10-21 20:37:50 | [diff] [blame] | 5555 | trans.reset(); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5556 | session_.reset(); |
| 5557 | } |
| 5558 | |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5559 | TEST_P(QuicNetworkTransactionTest, RetryAfterAsyncNoBufferSpace) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5560 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5561 | HostPortPair::FromString("mail.example.org:443")); |
| 5562 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5563 | MockQuicData socket_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5564 | int packet_num = 1; |
| 5565 | if (VersionUsesQpack(version_.transport_version)) { |
| 5566 | socket_data.AddWrite(SYNCHRONOUS, |
| 5567 | ConstructInitialSettingsPacket(packet_num++)); |
| 5568 | } |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5569 | socket_data.AddWrite(ASYNC, ERR_NO_BUFFER_SPACE); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5570 | socket_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5571 | SYNCHRONOUS, |
| 5572 | ConstructClientRequestHeadersPacket( |
| 5573 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 5574 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5575 | socket_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5576 | ASYNC, ConstructServerResponseHeadersPacket( |
| 5577 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 5578 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5579 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5580 | socket_data.AddRead( |
| 5581 | ASYNC, ConstructServerDataPacket( |
| 5582 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5583 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5584 | socket_data.AddWrite(SYNCHRONOUS, |
| 5585 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5586 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie | ba55fae | 2018-09-20 03:05:16 | [diff] [blame] | 5587 | socket_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5588 | SYNCHRONOUS, |
| 5589 | client_maker_.MakeAckAndConnectionClosePacket( |
| 5590 | packet_num++, false, quic::QuicTime::Delta::FromMilliseconds(0), 2, 1, |
| 5591 | 1, quic::QUIC_CONNECTION_CANCELLED, "net error", 0)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5592 | |
| 5593 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5594 | |
| 5595 | CreateSession(); |
| 5596 | |
| 5597 | SendRequestAndExpectQuicResponse("hello!"); |
| 5598 | session_.reset(); |
| 5599 | } |
| 5600 | |
| 5601 | TEST_P(QuicNetworkTransactionTest, RetryAfterSynchronousNoBufferSpace) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5602 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5603 | HostPortPair::FromString("mail.example.org:443")); |
| 5604 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5605 | MockQuicData socket_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5606 | int packet_num = 1; |
| 5607 | if (VersionUsesQpack(version_.transport_version)) { |
| 5608 | socket_data.AddWrite(SYNCHRONOUS, |
| 5609 | ConstructInitialSettingsPacket(packet_num++)); |
| 5610 | } |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5611 | socket_data.AddWrite(SYNCHRONOUS, ERR_NO_BUFFER_SPACE); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5612 | socket_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5613 | SYNCHRONOUS, |
| 5614 | ConstructClientRequestHeadersPacket( |
| 5615 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 5616 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5617 | socket_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5618 | ASYNC, ConstructServerResponseHeadersPacket( |
| 5619 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 5620 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5621 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5622 | socket_data.AddRead( |
| 5623 | ASYNC, ConstructServerDataPacket( |
| 5624 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5625 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5626 | socket_data.AddWrite(SYNCHRONOUS, |
| 5627 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5628 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie | ba55fae | 2018-09-20 03:05:16 | [diff] [blame] | 5629 | socket_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5630 | SYNCHRONOUS, |
| 5631 | client_maker_.MakeAckAndConnectionClosePacket( |
| 5632 | packet_num++, false, quic::QuicTime::Delta::FromMilliseconds(0), 2, 1, |
| 5633 | 1, quic::QUIC_CONNECTION_CANCELLED, "net error", 0)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5634 | |
| 5635 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5636 | |
| 5637 | CreateSession(); |
| 5638 | |
| 5639 | SendRequestAndExpectQuicResponse("hello!"); |
| 5640 | session_.reset(); |
| 5641 | } |
| 5642 | |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5643 | TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterAsyncNoBufferSpace) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5644 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
| 5645 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5646 | HostPortPair::FromString("mail.example.org:443")); |
| 5647 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5648 | MockQuicData socket_data(version_); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5649 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5650 | if (VersionUsesQpack(version_.transport_version)) |
| 5651 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5652 | for (int i = 0; i < 13; ++i) { // 12 retries then one final failure. |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5653 | socket_data.AddWrite(ASYNC, ERR_NO_BUFFER_SPACE); |
| 5654 | } |
| 5655 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5656 | |
| 5657 | CreateSession(); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5658 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5659 | QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(), |
| 5660 | quic_task_runner_.get()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5661 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5662 | quic::QuicTime start = clock_.Now(); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5663 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5664 | TestCompletionCallback callback; |
| 5665 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5666 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5667 | while (!callback.have_result()) { |
| 5668 | base::RunLoop().RunUntilIdle(); |
| 5669 | quic_task_runner_->RunUntilIdle(); |
| 5670 | } |
| 5671 | ASSERT_TRUE(callback.have_result()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5672 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5673 | EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 5674 | EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 5675 | // Backoff should take between 4 - 5 seconds. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5676 | EXPECT_TRUE(clock_.Now() - start > quic::QuicTime::Delta::FromSeconds(4)); |
| 5677 | EXPECT_TRUE(clock_.Now() - start < quic::QuicTime::Delta::FromSeconds(5)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5678 | } |
| 5679 | |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5680 | TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterSynchronousNoBufferSpace) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5681 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
| 5682 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5683 | HostPortPair::FromString("mail.example.org:443")); |
| 5684 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5685 | MockQuicData socket_data(version_); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5686 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5687 | if (VersionUsesQpack(version_.transport_version)) |
| 5688 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5689 | for (int i = 0; i < 13; ++i) { // 12 retries then one final failure. |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5690 | socket_data.AddWrite(ASYNC, ERR_NO_BUFFER_SPACE); |
| 5691 | } |
| 5692 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5693 | |
| 5694 | CreateSession(); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5695 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5696 | QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(), |
| 5697 | quic_task_runner_.get()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5698 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5699 | quic::QuicTime start = clock_.Now(); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5700 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5701 | TestCompletionCallback callback; |
| 5702 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5703 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5704 | while (!callback.have_result()) { |
| 5705 | base::RunLoop().RunUntilIdle(); |
| 5706 | quic_task_runner_->RunUntilIdle(); |
| 5707 | } |
| 5708 | ASSERT_TRUE(callback.have_result()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5709 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 5710 | EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 5711 | EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 5712 | // Backoff should take between 4 - 5 seconds. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5713 | EXPECT_TRUE(clock_.Now() - start > quic::QuicTime::Delta::FromSeconds(4)); |
| 5714 | EXPECT_TRUE(clock_.Now() - start < quic::QuicTime::Delta::FromSeconds(5)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5715 | } |
| 5716 | |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 5717 | TEST_P(QuicNetworkTransactionTest, NoMigrationForMsgTooBig) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5718 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
| 5719 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 5720 | HostPortPair::FromString("mail.example.org:443")); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5721 | const std::string error_details = |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5722 | quic::QuicStrCat("Write failed with error: ", ERR_MSG_TOO_BIG, " (", |
| 5723 | strerror(ERR_MSG_TOO_BIG), ")"); |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 5724 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5725 | MockQuicData socket_data(version_); |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 5726 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5727 | int packet_num = 1; |
| 5728 | if (VersionUsesQpack(version_.transport_version)) { |
| 5729 | socket_data.AddWrite(SYNCHRONOUS, |
| 5730 | ConstructInitialSettingsPacket(packet_num++)); |
| 5731 | } |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 5732 | socket_data.AddWrite(SYNCHRONOUS, ERR_MSG_TOO_BIG); |
| 5733 | // Connection close packet will be sent for MSG_TOO_BIG. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5734 | socket_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5735 | SYNCHRONOUS, |
| 5736 | client_maker_.MakeConnectionClosePacket( |
| 5737 | packet_num + 1, true, quic::QUIC_PACKET_WRITE_ERROR, error_details)); |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 5738 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5739 | |
| 5740 | CreateSession(); |
| 5741 | |
| 5742 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5743 | TestCompletionCallback callback; |
| 5744 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5745 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5746 | base::RunLoop().RunUntilIdle(); |
| 5747 | ASSERT_TRUE(callback.have_result()); |
| 5748 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 5749 | EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 5750 | EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 5751 | } |
| 5752 | |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 5753 | // Adds coverage to catch regression such as https://crbug.com/622043 |
| 5754 | TEST_P(QuicNetworkTransactionTest, QuicServerPush) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5755 | session_params_.quic_params.origins_to_force_quic_on.insert( |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 5756 | HostPortPair::FromString("mail.example.org:443")); |
| 5757 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5758 | MockQuicData mock_quic_data(version_); |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 5759 | uint64_t client_packet_number = 1; |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5760 | if (VersionUsesQpack(version_.transport_version)) { |
| 5761 | mock_quic_data.AddWrite( |
| 5762 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++)); |
| 5763 | } |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5764 | mock_quic_data.AddWrite( |
| 5765 | SYNCHRONOUS, |
| 5766 | ConstructClientRequestHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5767 | client_packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5768 | true, true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5769 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5770 | ASYNC, |
| 5771 | ConstructServerPushPromisePacket( |
| 5772 | 1, GetNthClientInitiatedBidirectionalStreamId(0), |
| 5773 | GetNthServerInitiatedUnidirectionalStreamId(0), false, |
| 5774 | GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_maker_)); |
Renjie Tang | 703fea9 | 2019-07-23 21:08:31 | [diff] [blame] | 5775 | if ((client_headers_include_h2_stream_dependency_ && |
| 5776 | version_.transport_version >= quic::QUIC_VERSION_43) || |
| 5777 | VersionHasStreamType(version_.transport_version)) { |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5778 | mock_quic_data.AddWrite( |
| 5779 | SYNCHRONOUS, |
| 5780 | ConstructClientPriorityPacket( |
| 5781 | client_packet_number++, false, |
| 5782 | GetNthServerInitiatedUnidirectionalStreamId(0), |
| 5783 | GetNthClientInitiatedBidirectionalStreamId(0), DEFAULT_PRIORITY)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 5784 | } |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5785 | mock_quic_data.AddRead( |
| 5786 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5787 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5788 | GetResponseHeaders("200 OK"))); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 5789 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5790 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
| 5791 | mock_quic_data.AddRead( |
| 5792 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5793 | 3, GetNthServerInitiatedUnidirectionalStreamId(0), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5794 | false, GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5795 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5796 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5797 | ASYNC, ConstructServerDataPacket( |
| 5798 | 4, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5799 | header + "hello!")); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 5800 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5801 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 4, 3, 1)); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5802 | std::string header2 = ConstructDataHeader(10); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5803 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5804 | ASYNC, ConstructServerDataPacket( |
| 5805 | 5, GetNthServerInitiatedUnidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5806 | header2 + "and hello!")); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5807 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5808 | ConstructClientAckAndRstPacket( |
| 5809 | client_packet_number++, |
| 5810 | GetNthServerInitiatedUnidirectionalStreamId(0), |
| 5811 | quic::QUIC_RST_ACKNOWLEDGEMENT, 5, 5, 1)); |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 5812 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 5813 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 5814 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5815 | |
| 5816 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5817 | // the alternate-protocol job will "win". |
| 5818 | AddHangingNonAlternateProtocolSocketData(); |
| 5819 | |
| 5820 | CreateSession(); |
| 5821 | |
| 5822 | // PUSH_PROMISE handling in the http layer gets exercised here. |
| 5823 | SendRequestAndExpectQuicResponse("hello!"); |
| 5824 | |
| 5825 | request_.url = GURL("https://mail.example.org/pushed.jpg"); |
| 5826 | SendRequestAndExpectQuicResponse("and hello!"); |
| 5827 | |
| 5828 | // Check that the NetLog was filled reasonably. |
Eric Roman | 79cc755 | 2019-07-19 02:17:54 | [diff] [blame] | 5829 | auto entries = net_log_.GetEntries(); |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 5830 | EXPECT_LT(0u, entries.size()); |
| 5831 | |
| 5832 | // Check that we logged a QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM |
| 5833 | int pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 5834 | entries, 0, NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM, |
| 5835 | NetLogEventPhase::NONE); |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 5836 | EXPECT_LT(0, pos); |
| 5837 | } |
| 5838 | |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5839 | // Regression test for http://crbug.com/719461 in which a promised stream |
| 5840 | // is closed before the pushed headers arrive, but after the connection |
| 5841 | // is closed and before the callbacks are executed. |
| 5842 | TEST_P(QuicNetworkTransactionTest, CancelServerPushAfterConnectionClose) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5843 | session_params_.quic_params.retry_without_alt_svc_on_quic_errors = false; |
| 5844 | session_params_.quic_params.origins_to_force_quic_on.insert( |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5845 | HostPortPair::FromString("mail.example.org:443")); |
| 5846 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5847 | MockQuicData mock_quic_data(version_); |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 5848 | uint64_t client_packet_number = 1; |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5849 | // Initial SETTINGS frame. |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5850 | if (VersionUsesQpack(version_.transport_version)) { |
| 5851 | mock_quic_data.AddWrite( |
| 5852 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++)); |
| 5853 | } |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5854 | // First request: GET https://mail.example.org/ |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5855 | mock_quic_data.AddWrite( |
| 5856 | SYNCHRONOUS, |
| 5857 | ConstructClientRequestHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5858 | client_packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5859 | true, true, GetRequestHeaders("GET", "https", "/"))); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5860 | // Server promise for: https://mail.example.org/pushed.jpg |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5861 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5862 | ASYNC, |
| 5863 | ConstructServerPushPromisePacket( |
| 5864 | 1, GetNthClientInitiatedBidirectionalStreamId(0), |
| 5865 | GetNthServerInitiatedUnidirectionalStreamId(0), false, |
| 5866 | GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_maker_)); |
Renjie Tang | 703fea9 | 2019-07-23 21:08:31 | [diff] [blame] | 5867 | if ((client_headers_include_h2_stream_dependency_ && |
| 5868 | version_.transport_version >= quic::QUIC_VERSION_43) || |
| 5869 | VersionHasStreamType(version_.transport_version)) { |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5870 | mock_quic_data.AddWrite( |
| 5871 | SYNCHRONOUS, |
| 5872 | ConstructClientPriorityPacket( |
| 5873 | client_packet_number++, false, |
| 5874 | GetNthServerInitiatedUnidirectionalStreamId(0), |
| 5875 | GetNthClientInitiatedBidirectionalStreamId(0), DEFAULT_PRIORITY)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 5876 | } |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5877 | // Response headers for first request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5878 | mock_quic_data.AddRead( |
| 5879 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5880 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5881 | GetResponseHeaders("200 OK"))); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5882 | // Client ACKs the response headers. |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 5883 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5884 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5885 | // Response body for first request. |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5886 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5887 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5888 | ASYNC, ConstructServerDataPacket( |
| 5889 | 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5890 | header + "hello!")); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5891 | // Write error for the third request. |
| 5892 | mock_quic_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
| 5893 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 5894 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 5895 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5896 | |
| 5897 | CreateSession(); |
| 5898 | |
| 5899 | // Send a request which triggers a push promise from the server. |
| 5900 | SendRequestAndExpectQuicResponse("hello!"); |
| 5901 | |
| 5902 | // Start a push transaction that will be cancelled after the connection |
| 5903 | // is closed, but before the callback is executed. |
| 5904 | request_.url = GURL("https://mail.example.org/pushed.jpg"); |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 5905 | auto trans2 = std::make_unique<HttpNetworkTransaction>(DEFAULT_PRIORITY, |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5906 | session_.get()); |
| 5907 | TestCompletionCallback callback2; |
| 5908 | int rv = trans2->Start(&request_, callback2.callback(), net_log_.bound()); |
| 5909 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5910 | base::RunLoop().RunUntilIdle(); |
| 5911 | |
| 5912 | // Cause the connection to close on a write error. |
| 5913 | HttpRequestInfo request3; |
| 5914 | request3.method = "GET"; |
| 5915 | request3.url = GURL("https://mail.example.org/"); |
| 5916 | request3.load_flags = 0; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 5917 | request3.traffic_annotation = |
| 5918 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 5919 | HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session_.get()); |
| 5920 | TestCompletionCallback callback3; |
| 5921 | EXPECT_THAT(trans3.Start(&request3, callback3.callback(), net_log_.bound()), |
| 5922 | IsError(ERR_IO_PENDING)); |
| 5923 | |
| 5924 | base::RunLoop().RunUntilIdle(); |
| 5925 | |
| 5926 | // When |trans2| is destroyed, the underlying stream will be closed. |
| 5927 | EXPECT_FALSE(callback2.have_result()); |
| 5928 | trans2 = nullptr; |
| 5929 | |
| 5930 | EXPECT_THAT(callback3.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 5931 | } |
| 5932 | |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 5933 | TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 5934 | session_params_.quic_params.origins_to_force_quic_on.insert( |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 5935 | HostPortPair::FromString("mail.example.org:443")); |
| 5936 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 5937 | MockQuicData mock_quic_data(version_); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 5938 | |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 5939 | int write_packet_index = 1; |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 5940 | if (VersionUsesQpack(version_.transport_version)) { |
| 5941 | mock_quic_data.AddWrite( |
| 5942 | SYNCHRONOUS, ConstructInitialSettingsPacket(write_packet_index++)); |
| 5943 | } |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 5944 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5945 | std::string header = ConstructDataHeader(1); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 5946 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 5947 | mock_quic_data.AddWrite( |
| 5948 | SYNCHRONOUS, |
| 5949 | ConstructClientRequestHeadersAndDataFramesPacket( |
| 5950 | write_packet_index++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 5951 | true, true, DEFAULT_PRIORITY, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5952 | GetRequestHeaders("POST", "https", "/"), 0, nullptr, {"1"})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 5953 | } else { |
| 5954 | mock_quic_data.AddWrite( |
| 5955 | SYNCHRONOUS, |
| 5956 | ConstructClientRequestHeadersAndDataFramesPacket( |
| 5957 | write_packet_index++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 5958 | true, true, DEFAULT_PRIORITY, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 5959 | GetRequestHeaders("POST", "https", "/"), 0, nullptr, |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 5960 | {header, "1"})); |
| 5961 | } |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 5962 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5963 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5964 | ASYNC, ConstructServerResponseHeadersPacket( |
| 5965 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 5966 | GetResponseHeaders("200 OK"))); |
| 5967 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 5968 | std::string header2 = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 5969 | mock_quic_data.AddRead( |
| 5970 | ASYNC, ConstructServerDataPacket( |
| 5971 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 5972 | header2 + "hello!")); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 5973 | |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 5974 | mock_quic_data.AddWrite( |
| 5975 | SYNCHRONOUS, ConstructClientAckPacket(write_packet_index++, 2, 1, 1)); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 5976 | |
| 5977 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 5978 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 5979 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5980 | |
| 5981 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5982 | // the alternate-protocol job will "win". |
| 5983 | AddHangingNonAlternateProtocolSocketData(); |
| 5984 | |
| 5985 | CreateSession(); |
| 5986 | request_.method = "POST"; |
| 5987 | ChunkedUploadDataStream upload_data(0); |
| 5988 | upload_data.AppendData("1", 1, true); |
| 5989 | |
| 5990 | request_.upload_data_stream = &upload_data; |
| 5991 | |
| 5992 | SendRequestAndExpectQuicResponse("hello!"); |
| 5993 | } |
| 5994 | |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 5995 | class QuicURLRequestContext : public URLRequestContext { |
| 5996 | public: |
| 5997 | QuicURLRequestContext(std::unique_ptr<HttpNetworkSession> session, |
| 5998 | MockClientSocketFactory* socket_factory) |
| 5999 | : storage_(this) { |
| 6000 | socket_factory_ = socket_factory; |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 6001 | storage_.set_host_resolver(std::make_unique<MockHostResolver>()); |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6002 | storage_.set_cert_verifier(std::make_unique<MockCertVerifier>()); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6003 | storage_.set_transport_security_state( |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6004 | std::make_unique<TransportSecurityState>()); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6005 | storage_.set_proxy_resolution_service( |
| 6006 | ProxyResolutionService::CreateDirect()); |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 6007 | storage_.set_ssl_config_service( |
| 6008 | std::make_unique<SSLConfigServiceDefaults>()); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6009 | storage_.set_http_auth_handler_factory( |
Eric Orth | be2efac | 2019-03-06 01:11:11 | [diff] [blame] | 6010 | HttpAuthHandlerFactory::CreateDefault()); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6011 | storage_.set_http_server_properties( |
Matt Menke | 60916074 | 2019-08-02 18:47:26 | [diff] [blame] | 6012 | std::make_unique<HttpServerProperties>()); |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6013 | storage_.set_job_factory(std::make_unique<URLRequestJobFactoryImpl>()); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6014 | storage_.set_http_network_session(std::move(session)); |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6015 | storage_.set_http_transaction_factory(std::make_unique<HttpCache>( |
| 6016 | storage_.http_network_session(), HttpCache::DefaultBackend::InMemory(0), |
| 6017 | false)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6018 | } |
| 6019 | |
| 6020 | ~QuicURLRequestContext() override { AssertNoURLRequests(); } |
| 6021 | |
| 6022 | MockClientSocketFactory& socket_factory() { return *socket_factory_; } |
| 6023 | |
| 6024 | private: |
| 6025 | MockClientSocketFactory* socket_factory_; |
| 6026 | URLRequestContextStorage storage_; |
| 6027 | }; |
| 6028 | |
| 6029 | TEST_P(QuicNetworkTransactionTest, RawHeaderSizeSuccessfullRequest) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 6030 | session_params_.quic_params.origins_to_force_quic_on.insert( |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6031 | HostPortPair::FromString("mail.example.org:443")); |
| 6032 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6033 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6034 | int packet_num = 1; |
| 6035 | if (VersionUsesQpack(version_.transport_version)) { |
| 6036 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6037 | ConstructInitialSettingsPacket(packet_num++)); |
| 6038 | } |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6039 | spdy::SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6040 | headers["user-agent"] = ""; |
| 6041 | headers["accept-encoding"] = "gzip, deflate"; |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6042 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6043 | SYNCHRONOUS, |
| 6044 | ConstructClientRequestHeadersPacket( |
| 6045 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 6046 | true, std::move(headers))); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6047 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6048 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6049 | ASYNC, ConstructServerResponseHeadersPacket( |
| 6050 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 6051 | GetResponseHeaders("200 OK"))); |
| 6052 | quic::QuicStreamOffset expected_raw_header_response_size = |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 6053 | server_maker_.stream_offset( |
| 6054 | quic::VersionUsesQpack(version_.transport_version) |
| 6055 | ? GetNthClientInitiatedBidirectionalStreamId(0) |
| 6056 | : quic::QuicUtils::GetHeadersStreamId( |
| 6057 | version_.transport_version)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6058 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6059 | std::string header = ConstructDataHeader(18); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6060 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6061 | ASYNC, ConstructServerDataPacket( |
| 6062 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6063 | "Main Resource Data")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6064 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6065 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6066 | |
| 6067 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6068 | |
| 6069 | CreateSession(); |
| 6070 | |
| 6071 | TestDelegate delegate; |
| 6072 | QuicURLRequestContext quic_url_request_context(std::move(session_), |
| 6073 | &socket_factory_); |
| 6074 | |
| 6075 | mock_quic_data.AddSocketDataToFactory( |
| 6076 | &quic_url_request_context.socket_factory()); |
| 6077 | TestNetworkDelegate network_delegate; |
| 6078 | quic_url_request_context.set_network_delegate(&network_delegate); |
| 6079 | |
| 6080 | std::unique_ptr<URLRequest> request(quic_url_request_context.CreateRequest( |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 6081 | GURL("https://mail.example.org/"), DEFAULT_PRIORITY, &delegate, |
| 6082 | TRAFFIC_ANNOTATION_FOR_TESTS)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6083 | quic_url_request_context.socket_factory().AddSSLSocketDataProvider( |
| 6084 | &ssl_data_); |
| 6085 | |
| 6086 | request->Start(); |
Wez | 2a31b22 | 2018-06-07 22:07:15 | [diff] [blame] | 6087 | delegate.RunUntilComplete(); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6088 | |
| 6089 | EXPECT_LT(0, request->GetTotalSentBytes()); |
| 6090 | EXPECT_LT(0, request->GetTotalReceivedBytes()); |
| 6091 | EXPECT_EQ(network_delegate.total_network_bytes_sent(), |
| 6092 | request->GetTotalSentBytes()); |
| 6093 | EXPECT_EQ(network_delegate.total_network_bytes_received(), |
| 6094 | request->GetTotalReceivedBytes()); |
| 6095 | EXPECT_EQ(static_cast<int>(expected_raw_header_response_size), |
| 6096 | request->raw_header_size()); |
Wez | 0e71711 | 2018-06-18 23:09:22 | [diff] [blame] | 6097 | |
| 6098 | // Pump the message loop to allow all data to be consumed. |
| 6099 | base::RunLoop().RunUntilIdle(); |
| 6100 | |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6101 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 6102 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 6103 | } |
| 6104 | |
| 6105 | TEST_P(QuicNetworkTransactionTest, RawHeaderSizeSuccessfullPushHeadersFirst) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 6106 | session_params_.quic_params.origins_to_force_quic_on.insert( |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6107 | HostPortPair::FromString("mail.example.org:443")); |
| 6108 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6109 | MockQuicData mock_quic_data(version_); |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6110 | uint64_t client_packet_number = 1; |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6111 | if (VersionUsesQpack(version_.transport_version)) { |
| 6112 | mock_quic_data.AddWrite( |
| 6113 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++)); |
| 6114 | } |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6115 | spdy::SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6116 | headers["user-agent"] = ""; |
| 6117 | headers["accept-encoding"] = "gzip, deflate"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6118 | mock_quic_data.AddWrite( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6119 | SYNCHRONOUS, |
| 6120 | ConstructClientRequestHeadersPacket( |
| 6121 | client_packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6122 | true, true, std::move(headers))); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6123 | |
Fan Yang | 2330d18 | 2019-08-05 14:50:50 | [diff] [blame] | 6124 | const quic::QuicStreamOffset initial = server_maker_.stream_offset( |
| 6125 | GetNthClientInitiatedBidirectionalStreamId(0)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6126 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6127 | ASYNC, |
| 6128 | ConstructServerPushPromisePacket( |
| 6129 | 1, GetNthClientInitiatedBidirectionalStreamId(0), |
| 6130 | GetNthServerInitiatedUnidirectionalStreamId(0), false, |
| 6131 | GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_maker_)); |
Fan Yang | 2330d18 | 2019-08-05 14:50:50 | [diff] [blame] | 6132 | quic::QuicStreamOffset push_promise_offset = 0; |
| 6133 | if (VersionUsesQpack(version_.transport_version)) { |
| 6134 | push_promise_offset = server_maker_.stream_offset( |
| 6135 | GetNthClientInitiatedBidirectionalStreamId(0)) - |
| 6136 | initial; |
| 6137 | } |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6138 | |
Renjie Tang | 703fea9 | 2019-07-23 21:08:31 | [diff] [blame] | 6139 | if ((client_headers_include_h2_stream_dependency_ && |
| 6140 | version_.transport_version >= quic::QUIC_VERSION_43) || |
| 6141 | VersionHasStreamType(version_.transport_version)) { |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6142 | mock_quic_data.AddWrite( |
| 6143 | SYNCHRONOUS, |
| 6144 | ConstructClientPriorityPacket( |
| 6145 | client_packet_number++, false, |
| 6146 | GetNthServerInitiatedUnidirectionalStreamId(0), |
| 6147 | GetNthClientInitiatedBidirectionalStreamId(0), DEFAULT_PRIORITY)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6148 | } |
| 6149 | |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 6150 | const quic::QuicStreamOffset initial_offset = server_maker_.stream_offset( |
| 6151 | quic::VersionUsesQpack(version_.transport_version) |
| 6152 | ? GetNthClientInitiatedBidirectionalStreamId(0) |
| 6153 | : quic::QuicUtils::GetHeadersStreamId(version_.transport_version)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6154 | mock_quic_data.AddRead( |
| 6155 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6156 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6157 | GetResponseHeaders("200 OK"))); |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 6158 | const quic::QuicStreamOffset final_offset = server_maker_.stream_offset( |
| 6159 | quic::VersionUsesQpack(version_.transport_version) |
| 6160 | ? GetNthClientInitiatedBidirectionalStreamId(0) |
| 6161 | : quic::QuicUtils::GetHeadersStreamId(version_.transport_version)); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6162 | quic::QuicStreamOffset expected_raw_header_response_size = |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 6163 | final_offset - initial_offset; |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6164 | |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6165 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6166 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6167 | |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6168 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6169 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6170 | 3, GetNthServerInitiatedUnidirectionalStreamId(0), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6171 | false, GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6172 | std::string header = ConstructDataHeader(20); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6173 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6174 | ASYNC, ConstructServerDataPacket( |
| 6175 | 4, GetNthServerInitiatedUnidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6176 | header + "Pushed Resource Data")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6177 | |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6178 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6179 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 4, 3, 1)); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6180 | std::string header2 = ConstructDataHeader(18); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6181 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6182 | ASYNC, ConstructServerDataPacket( |
| 6183 | 5, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6184 | header2 + "Main Resource Data")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6185 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6186 | mock_quic_data.AddRead(ASYNC, ConstructServerConnectionClosePacket(6)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6187 | |
| 6188 | CreateSession(); |
| 6189 | |
| 6190 | TestDelegate delegate; |
| 6191 | QuicURLRequestContext quic_url_request_context(std::move(session_), |
| 6192 | &socket_factory_); |
| 6193 | |
| 6194 | mock_quic_data.AddSocketDataToFactory( |
| 6195 | &quic_url_request_context.socket_factory()); |
| 6196 | TestNetworkDelegate network_delegate; |
| 6197 | quic_url_request_context.set_network_delegate(&network_delegate); |
| 6198 | |
| 6199 | std::unique_ptr<URLRequest> request(quic_url_request_context.CreateRequest( |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 6200 | GURL("https://mail.example.org/"), DEFAULT_PRIORITY, &delegate, |
| 6201 | TRAFFIC_ANNOTATION_FOR_TESTS)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6202 | quic_url_request_context.socket_factory().AddSSLSocketDataProvider( |
| 6203 | &ssl_data_); |
| 6204 | |
| 6205 | request->Start(); |
Wez | 2a31b22 | 2018-06-07 22:07:15 | [diff] [blame] | 6206 | delegate.RunUntilComplete(); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6207 | |
| 6208 | EXPECT_LT(0, request->GetTotalSentBytes()); |
| 6209 | EXPECT_LT(0, request->GetTotalReceivedBytes()); |
| 6210 | EXPECT_EQ(network_delegate.total_network_bytes_sent(), |
| 6211 | request->GetTotalSentBytes()); |
| 6212 | EXPECT_EQ(network_delegate.total_network_bytes_received(), |
| 6213 | request->GetTotalReceivedBytes()); |
Fan Yang | 2330d18 | 2019-08-05 14:50:50 | [diff] [blame] | 6214 | EXPECT_EQ( |
| 6215 | static_cast<int>(expected_raw_header_response_size + push_promise_offset), |
| 6216 | request->raw_header_size()); |
Wez | 0e71711 | 2018-06-18 23:09:22 | [diff] [blame] | 6217 | |
| 6218 | // Pump the message loop to allow all data to be consumed. |
| 6219 | base::RunLoop().RunUntilIdle(); |
| 6220 | |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6221 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 6222 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 6223 | } |
| 6224 | |
Ryan Sleevi | a9d6aa6 | 2019-07-26 13:32:18 | [diff] [blame] | 6225 | TEST_P(QuicNetworkTransactionTest, HostInAllowlist) { |
| 6226 | session_params_.quic_host_allowlist.insert("mail.example.org"); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6227 | |
| 6228 | MockRead http_reads[] = { |
| 6229 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 6230 | MockRead("hello world"), |
| 6231 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 6232 | MockRead(ASYNC, OK)}; |
| 6233 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 6234 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6235 | socket_factory_.AddSocketDataProvider(&http_data); |
| 6236 | AddCertificate(&ssl_data_); |
| 6237 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6238 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6239 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6240 | int packet_num = 1; |
| 6241 | if (VersionUsesQpack(version_.transport_version)) { |
| 6242 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6243 | ConstructInitialSettingsPacket(packet_num++)); |
| 6244 | } |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6245 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6246 | SYNCHRONOUS, |
| 6247 | ConstructClientRequestHeadersPacket( |
| 6248 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 6249 | true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6250 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6251 | ASYNC, ConstructServerResponseHeadersPacket( |
| 6252 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 6253 | GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6254 | std::string header = ConstructDataHeader(6); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6255 | mock_quic_data.AddRead( |
| 6256 | ASYNC, ConstructServerDataPacket( |
| 6257 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6258 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6259 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6260 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6261 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6262 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6263 | |
| 6264 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6265 | |
| 6266 | AddHangingNonAlternateProtocolSocketData(); |
| 6267 | CreateSession(); |
| 6268 | |
| 6269 | SendRequestAndExpectHttpResponse("hello world"); |
| 6270 | SendRequestAndExpectQuicResponse("hello!"); |
| 6271 | } |
| 6272 | |
Ryan Sleevi | a9d6aa6 | 2019-07-26 13:32:18 | [diff] [blame] | 6273 | TEST_P(QuicNetworkTransactionTest, HostNotInAllowlist) { |
| 6274 | session_params_.quic_host_allowlist.insert("mail.example.com"); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6275 | |
| 6276 | MockRead http_reads[] = { |
| 6277 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 6278 | MockRead("hello world"), |
| 6279 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 6280 | MockRead(ASYNC, OK)}; |
| 6281 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 6282 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6283 | socket_factory_.AddSocketDataProvider(&http_data); |
| 6284 | AddCertificate(&ssl_data_); |
| 6285 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6286 | socket_factory_.AddSocketDataProvider(&http_data); |
| 6287 | AddCertificate(&ssl_data_); |
| 6288 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6289 | |
| 6290 | AddHangingNonAlternateProtocolSocketData(); |
| 6291 | CreateSession(); |
| 6292 | |
| 6293 | SendRequestAndExpectHttpResponse("hello world"); |
| 6294 | SendRequestAndExpectHttpResponse("hello world"); |
| 6295 | } |
| 6296 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6297 | class QuicNetworkTransactionWithDestinationTest |
| 6298 | : public PlatformTest, |
Bence Béky | 98447b1 | 2018-05-08 03:14:01 | [diff] [blame] | 6299 | public ::testing::WithParamInterface<PoolingTestParams>, |
Gabriel Charette | 694c3c33 | 2019-08-19 14:53:05 | [diff] [blame] | 6300 | public WithTaskEnvironment { |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6301 | protected: |
| 6302 | QuicNetworkTransactionWithDestinationTest() |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 6303 | : version_(GetParam().version), |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6304 | client_headers_include_h2_stream_dependency_( |
| 6305 | GetParam().client_headers_include_h2_stream_dependency), |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 6306 | supported_versions_(quic::test::SupportedVersions(version_)), |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6307 | destination_type_(GetParam().destination_type), |
| 6308 | cert_transparency_verifier_(new MultiLogCTVerifier()), |
| 6309 | ssl_config_service_(new SSLConfigServiceDefaults), |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6310 | proxy_resolution_service_(ProxyResolutionService::CreateDirect()), |
Eric Orth | be2efac | 2019-03-06 01:11:11 | [diff] [blame] | 6311 | auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()), |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6312 | random_generator_(0), |
| 6313 | ssl_data_(ASYNC, OK) {} |
| 6314 | |
| 6315 | void SetUp() override { |
| 6316 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 6317 | base::RunLoop().RunUntilIdle(); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6318 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6319 | HttpNetworkSession::Params session_params; |
| 6320 | session_params.enable_quic = true; |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 6321 | session_params.quic_params.allow_remote_alt_svc = true; |
| 6322 | session_params.quic_params.supported_versions = supported_versions_; |
| 6323 | session_params.quic_params.headers_include_h2_stream_dependency = |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6324 | client_headers_include_h2_stream_dependency_; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6325 | |
| 6326 | HttpNetworkSession::Context session_context; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6327 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6328 | clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20)); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6329 | session_context.quic_clock = &clock_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6330 | |
| 6331 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 6332 | MockCryptoClientStream::CONFIRM_HANDSHAKE); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6333 | session_context.quic_crypto_client_stream_factory = |
| 6334 | &crypto_client_stream_factory_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6335 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6336 | session_context.quic_random = &random_generator_; |
| 6337 | session_context.client_socket_factory = &socket_factory_; |
| 6338 | session_context.host_resolver = &host_resolver_; |
| 6339 | session_context.cert_verifier = &cert_verifier_; |
| 6340 | session_context.transport_security_state = &transport_security_state_; |
| 6341 | session_context.cert_transparency_verifier = |
| 6342 | cert_transparency_verifier_.get(); |
| 6343 | session_context.ct_policy_enforcer = &ct_policy_enforcer_; |
| 6344 | session_context.socket_performance_watcher_factory = |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6345 | &test_socket_performance_watcher_factory_; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6346 | session_context.ssl_config_service = ssl_config_service_.get(); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6347 | session_context.proxy_resolution_service = proxy_resolution_service_.get(); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6348 | session_context.http_auth_handler_factory = auth_handler_factory_.get(); |
| 6349 | session_context.http_server_properties = &http_server_properties_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6350 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6351 | session_.reset(new HttpNetworkSession(session_params, session_context)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6352 | session_->quic_stream_factory()->set_require_confirmation(true); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6353 | } |
| 6354 | |
| 6355 | void TearDown() override { |
| 6356 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 6357 | // Empty the current queue. |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 6358 | base::RunLoop().RunUntilIdle(); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6359 | PlatformTest::TearDown(); |
| 6360 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 6361 | base::RunLoop().RunUntilIdle(); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 6362 | session_.reset(); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6363 | } |
| 6364 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6365 | void SetQuicAlternativeService(const std::string& origin) { |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6366 | HostPortPair destination; |
| 6367 | switch (destination_type_) { |
| 6368 | case SAME_AS_FIRST: |
| 6369 | destination = HostPortPair(origin1_, 443); |
| 6370 | break; |
| 6371 | case SAME_AS_SECOND: |
| 6372 | destination = HostPortPair(origin2_, 443); |
| 6373 | break; |
| 6374 | case DIFFERENT: |
| 6375 | destination = HostPortPair(kDifferentHostname, 443); |
| 6376 | break; |
| 6377 | } |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 6378 | AlternativeService alternative_service(kProtoQUIC, destination); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6379 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6380 | http_server_properties_.SetQuicAlternativeService( |
Matt Menke | 9aa8626 | 2019-08-21 15:52:07 | [diff] [blame] | 6381 | url::SchemeHostPort("https", origin, 443), NetworkIsolationKey(), |
| 6382 | alternative_service, expiration, supported_versions_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6383 | } |
| 6384 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6385 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6386 | ConstructClientRequestHeadersPacket(uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6387 | quic::QuicStreamId stream_id, |
| 6388 | bool should_include_version, |
| 6389 | quic::QuicStreamId parent_stream_id, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6390 | QuicTestPacketMaker* maker) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6391 | spdy::SpdyPriority priority = |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6392 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6393 | spdy::SpdyHeaderBlock headers( |
| 6394 | maker->GetRequestHeaders("GET", "https", "/")); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6395 | return maker->MakeRequestHeadersPacket( |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6396 | packet_number, stream_id, should_include_version, true, priority, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6397 | std::move(headers), parent_stream_id, nullptr); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6398 | } |
| 6399 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6400 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6401 | ConstructClientRequestHeadersPacket(uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6402 | quic::QuicStreamId stream_id, |
| 6403 | bool should_include_version, |
| 6404 | QuicTestPacketMaker* maker) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 6405 | return ConstructClientRequestHeadersPacket( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6406 | packet_number, stream_id, should_include_version, 0, maker); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6407 | } |
| 6408 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6409 | std::unique_ptr<quic::QuicEncryptedPacket> |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6410 | ConstructServerResponseHeadersPacket(uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6411 | quic::QuicStreamId stream_id, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6412 | QuicTestPacketMaker* maker) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6413 | spdy::SpdyHeaderBlock headers(maker->GetResponseHeaders("200 OK")); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6414 | return maker->MakeResponseHeadersPacket(packet_number, stream_id, false, |
| 6415 | false, std::move(headers), nullptr); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6416 | } |
| 6417 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6418 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6419 | uint64_t packet_number, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6420 | quic::QuicStreamId stream_id, |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6421 | QuicTestPacketMaker* maker) { |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6422 | std::string header = ""; |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 6423 | if (version_.transport_version == quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 6424 | quic::HttpEncoder encoder; |
| 6425 | std::unique_ptr<char[]> buffer; |
| 6426 | auto header_length = encoder.SerializeDataFrameHeader(5, &buffer); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6427 | header = std::string(buffer.get(), header_length); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 6428 | } |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6429 | return maker->MakeDataPacket(packet_number, stream_id, false, true, |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 6430 | header + "hello"); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6431 | } |
| 6432 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6433 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6434 | uint64_t packet_number, |
| 6435 | uint64_t largest_received, |
| 6436 | uint64_t smallest_received, |
| 6437 | uint64_t least_unacked, |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6438 | QuicTestPacketMaker* maker) { |
| 6439 | return maker->MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 6440 | smallest_received, least_unacked, true); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6441 | } |
| 6442 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6443 | std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket( |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6444 | uint64_t packet_number, |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 6445 | QuicTestPacketMaker* maker) { |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6446 | return maker->MakeInitialSettingsPacket(packet_number); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 6447 | } |
| 6448 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6449 | void AddRefusedSocketData() { |
| 6450 | std::unique_ptr<StaticSocketDataProvider> refused_data( |
| 6451 | new StaticSocketDataProvider()); |
| 6452 | MockConnect refused_connect(SYNCHRONOUS, ERR_CONNECTION_REFUSED); |
| 6453 | refused_data->set_connect_data(refused_connect); |
| 6454 | socket_factory_.AddSocketDataProvider(refused_data.get()); |
| 6455 | static_socket_data_provider_vector_.push_back(std::move(refused_data)); |
| 6456 | } |
| 6457 | |
| 6458 | void AddHangingSocketData() { |
| 6459 | std::unique_ptr<StaticSocketDataProvider> hanging_data( |
| 6460 | new StaticSocketDataProvider()); |
| 6461 | MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING); |
| 6462 | hanging_data->set_connect_data(hanging_connect); |
| 6463 | socket_factory_.AddSocketDataProvider(hanging_data.get()); |
| 6464 | static_socket_data_provider_vector_.push_back(std::move(hanging_data)); |
| 6465 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6466 | } |
| 6467 | |
| 6468 | bool AllDataConsumed() { |
| 6469 | for (const auto& socket_data_ptr : static_socket_data_provider_vector_) { |
| 6470 | if (!socket_data_ptr->AllReadDataConsumed() || |
| 6471 | !socket_data_ptr->AllWriteDataConsumed()) { |
| 6472 | return false; |
| 6473 | } |
| 6474 | } |
| 6475 | return true; |
| 6476 | } |
| 6477 | |
| 6478 | void SendRequestAndExpectQuicResponse(const std::string& host) { |
| 6479 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 6480 | HttpRequestInfo request; |
| 6481 | std::string url("https://"); |
| 6482 | url.append(host); |
| 6483 | request.url = GURL(url); |
| 6484 | request.load_flags = 0; |
| 6485 | request.method = "GET"; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 6486 | request.traffic_annotation = |
| 6487 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6488 | TestCompletionCallback callback; |
| 6489 | int rv = trans.Start(&request, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 6490 | EXPECT_THAT(callback.GetResult(rv), IsOk()); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6491 | |
| 6492 | std::string response_data; |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 6493 | ASSERT_THAT(ReadTransaction(&trans, &response_data), IsOk()); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6494 | EXPECT_EQ("hello", response_data); |
| 6495 | |
| 6496 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
| 6497 | ASSERT_TRUE(response != nullptr); |
| 6498 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 6499 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 6500 | EXPECT_TRUE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 6501 | EXPECT_TRUE(response->was_alpn_negotiated); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 6502 | EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion( |
| 6503 | version_.transport_version), |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6504 | response->connection_info); |
Tsuyoshi Horo | 01faed6 | 2019-02-20 22:11:37 | [diff] [blame] | 6505 | EXPECT_EQ(443, response->remote_endpoint.port()); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6506 | } |
| 6507 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6508 | quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) { |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 6509 | return quic::test::GetNthClientInitiatedBidirectionalStreamId( |
| 6510 | version_.transport_version, n); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6511 | } |
| 6512 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6513 | quic::MockClock clock_; |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 6514 | const quic::ParsedQuicVersion version_; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6515 | const bool client_headers_include_h2_stream_dependency_; |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 6516 | quic::ParsedQuicVersionVector supported_versions_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6517 | DestinationType destination_type_; |
| 6518 | std::string origin1_; |
| 6519 | std::string origin2_; |
| 6520 | std::unique_ptr<HttpNetworkSession> session_; |
| 6521 | MockClientSocketFactory socket_factory_; |
| 6522 | MockHostResolver host_resolver_; |
| 6523 | MockCertVerifier cert_verifier_; |
| 6524 | TransportSecurityState transport_security_state_; |
| 6525 | std::unique_ptr<CTVerifier> cert_transparency_verifier_; |
Ryan Sleevi | 8a9c9c1 | 2018-05-09 02:36:23 | [diff] [blame] | 6526 | DefaultCTPolicyEnforcer ct_policy_enforcer_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6527 | TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_; |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 6528 | std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6529 | std::unique_ptr<ProxyResolutionService> proxy_resolution_service_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6530 | std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6531 | quic::test::MockRandom random_generator_; |
Matt Menke | 60916074 | 2019-08-02 18:47:26 | [diff] [blame] | 6532 | HttpServerProperties http_server_properties_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6533 | BoundTestNetLog net_log_; |
| 6534 | MockCryptoClientStreamFactory crypto_client_stream_factory_; |
| 6535 | std::vector<std::unique_ptr<StaticSocketDataProvider>> |
| 6536 | static_socket_data_provider_vector_; |
| 6537 | SSLSocketDataProvider ssl_data_; |
| 6538 | }; |
| 6539 | |
Victor Costan | e635086f | 2019-01-27 05:20:30 | [diff] [blame] | 6540 | INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence, |
| 6541 | QuicNetworkTransactionWithDestinationTest, |
| 6542 | ::testing::ValuesIn(GetPoolingTestParams())); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6543 | |
| 6544 | // A single QUIC request fails because the certificate does not match the origin |
| 6545 | // hostname, regardless of whether it matches the alternative service hostname. |
| 6546 | TEST_P(QuicNetworkTransactionWithDestinationTest, InvalidCertificate) { |
| 6547 | if (destination_type_ == DIFFERENT) |
| 6548 | return; |
| 6549 | |
| 6550 | GURL url("https://mail.example.com/"); |
| 6551 | origin1_ = url.host(); |
| 6552 | |
| 6553 | // Not used for requests, but this provides a test case where the certificate |
| 6554 | // is valid for the hostname of the alternative service. |
| 6555 | origin2_ = "mail.example.org"; |
| 6556 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6557 | SetQuicAlternativeService(origin1_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6558 | |
| 6559 | scoped_refptr<X509Certificate> cert( |
| 6560 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 6561 | ASSERT_FALSE(cert->VerifyNameMatch(origin1_)); |
| 6562 | ASSERT_TRUE(cert->VerifyNameMatch(origin2_)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6563 | |
| 6564 | ProofVerifyDetailsChromium verify_details; |
| 6565 | verify_details.cert_verify_result.verified_cert = cert; |
| 6566 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 6567 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 6568 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6569 | MockQuicData mock_quic_data(version_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6570 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 6571 | mock_quic_data.AddRead(ASYNC, 0); |
| 6572 | |
| 6573 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6574 | |
| 6575 | AddRefusedSocketData(); |
| 6576 | |
| 6577 | HttpRequestInfo request; |
| 6578 | request.url = url; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 6579 | request.traffic_annotation = |
| 6580 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6581 | |
| 6582 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 6583 | TestCompletionCallback callback; |
| 6584 | int rv = trans.Start(&request, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 6585 | EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6586 | |
| 6587 | EXPECT_TRUE(AllDataConsumed()); |
| 6588 | } |
| 6589 | |
| 6590 | // First request opens QUIC session to alternative service. Second request |
| 6591 | // pools to it, because destination matches and certificate is valid, even |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6592 | // though quic::QuicServerId is different. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6593 | TEST_P(QuicNetworkTransactionWithDestinationTest, PoolIfCertificateValid) { |
| 6594 | origin1_ = "mail.example.org"; |
| 6595 | origin2_ = "news.example.org"; |
| 6596 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6597 | SetQuicAlternativeService(origin1_); |
| 6598 | SetQuicAlternativeService(origin2_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6599 | |
| 6600 | scoped_refptr<X509Certificate> cert( |
| 6601 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 6602 | ASSERT_TRUE(cert->VerifyNameMatch(origin1_)); |
| 6603 | ASSERT_TRUE(cert->VerifyNameMatch(origin2_)); |
| 6604 | ASSERT_FALSE(cert->VerifyNameMatch(kDifferentHostname)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6605 | |
| 6606 | ProofVerifyDetailsChromium verify_details; |
| 6607 | verify_details.cert_verify_result.verified_cert = cert; |
| 6608 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 6609 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 6610 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6611 | QuicTestPacketMaker client_maker( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 6612 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 6613 | &clock_, origin1_, quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6614 | client_headers_include_h2_stream_dependency_); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 6615 | QuicTestPacketMaker server_maker( |
| 6616 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 6617 | &clock_, origin1_, quic::Perspective::IS_SERVER, false); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6618 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6619 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6620 | int packet_num = 1; |
| 6621 | if (VersionUsesQpack(version_.transport_version)) { |
| 6622 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket( |
| 6623 | packet_num++, &client_maker)); |
| 6624 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6625 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6626 | SYNCHRONOUS, |
| 6627 | ConstructClientRequestHeadersPacket( |
| 6628 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 6629 | &client_maker)); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6630 | mock_quic_data.AddRead( |
| 6631 | ASYNC, |
| 6632 | ConstructServerResponseHeadersPacket( |
| 6633 | 1, GetNthClientInitiatedBidirectionalStreamId(0), &server_maker)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6634 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6635 | ASYNC, |
| 6636 | ConstructServerDataPacket( |
| 6637 | 2, GetNthClientInitiatedBidirectionalStreamId(0), &server_maker)); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6638 | mock_quic_data.AddWrite( |
| 6639 | SYNCHRONOUS, |
| 6640 | ConstructClientAckPacket(packet_num++, 2, 1, 1, &client_maker)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6641 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6642 | client_maker.set_hostname(origin2_); |
| 6643 | server_maker.set_hostname(origin2_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6644 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6645 | mock_quic_data.AddWrite( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6646 | SYNCHRONOUS, |
| 6647 | ConstructClientRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6648 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6649 | GetNthClientInitiatedBidirectionalStreamId(0), &client_maker)); |
| 6650 | mock_quic_data.AddRead( |
| 6651 | ASYNC, |
| 6652 | ConstructServerResponseHeadersPacket( |
| 6653 | 3, GetNthClientInitiatedBidirectionalStreamId(1), &server_maker)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6654 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6655 | ASYNC, |
| 6656 | ConstructServerDataPacket( |
| 6657 | 4, GetNthClientInitiatedBidirectionalStreamId(1), &server_maker)); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6658 | mock_quic_data.AddWrite( |
| 6659 | SYNCHRONOUS, |
| 6660 | ConstructClientAckPacket(packet_num++, 4, 3, 1, &client_maker)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6661 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6662 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6663 | |
| 6664 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6665 | |
| 6666 | AddHangingSocketData(); |
| 6667 | AddHangingSocketData(); |
| 6668 | |
Nick Harper | eb483e1 | 2019-05-14 00:18:09 | [diff] [blame] | 6669 | scoped_refptr<TestTaskRunner> quic_task_runner(new TestTaskRunner(&clock_)); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 6670 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 6671 | session_->quic_stream_factory(), |
Nick Harper | eb483e1 | 2019-05-14 00:18:09 | [diff] [blame] | 6672 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner.get(), |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame] | 6673 | &clock_)); |
| 6674 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6675 | SendRequestAndExpectQuicResponse(origin1_); |
| 6676 | SendRequestAndExpectQuicResponse(origin2_); |
| 6677 | |
| 6678 | EXPECT_TRUE(AllDataConsumed()); |
| 6679 | } |
| 6680 | |
| 6681 | // First request opens QUIC session to alternative service. Second request does |
| 6682 | // not pool to it, even though destination matches, because certificate is not |
| 6683 | // valid. Instead, a new QUIC session is opened to the same destination with a |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6684 | // different quic::QuicServerId. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6685 | TEST_P(QuicNetworkTransactionWithDestinationTest, |
| 6686 | DoNotPoolIfCertificateInvalid) { |
| 6687 | origin1_ = "news.example.org"; |
| 6688 | origin2_ = "mail.example.com"; |
| 6689 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6690 | SetQuicAlternativeService(origin1_); |
| 6691 | SetQuicAlternativeService(origin2_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6692 | |
| 6693 | scoped_refptr<X509Certificate> cert1( |
| 6694 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 6695 | ASSERT_TRUE(cert1->VerifyNameMatch(origin1_)); |
| 6696 | ASSERT_FALSE(cert1->VerifyNameMatch(origin2_)); |
| 6697 | ASSERT_FALSE(cert1->VerifyNameMatch(kDifferentHostname)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6698 | |
| 6699 | scoped_refptr<X509Certificate> cert2( |
| 6700 | ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 6701 | ASSERT_TRUE(cert2->VerifyNameMatch(origin2_)); |
| 6702 | ASSERT_FALSE(cert2->VerifyNameMatch(kDifferentHostname)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6703 | |
| 6704 | ProofVerifyDetailsChromium verify_details1; |
| 6705 | verify_details1.cert_verify_result.verified_cert = cert1; |
| 6706 | verify_details1.cert_verify_result.is_issued_by_known_root = true; |
| 6707 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1); |
| 6708 | |
| 6709 | ProofVerifyDetailsChromium verify_details2; |
| 6710 | verify_details2.cert_verify_result.verified_cert = cert2; |
| 6711 | verify_details2.cert_verify_result.is_issued_by_known_root = true; |
| 6712 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); |
| 6713 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6714 | QuicTestPacketMaker client_maker1( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 6715 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 6716 | &clock_, origin1_, quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6717 | client_headers_include_h2_stream_dependency_); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 6718 | QuicTestPacketMaker server_maker1( |
| 6719 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 6720 | &clock_, origin1_, quic::Perspective::IS_SERVER, false); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6721 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6722 | MockQuicData mock_quic_data1(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6723 | int packet_num = 1; |
| 6724 | if (VersionUsesQpack(version_.transport_version)) { |
| 6725 | mock_quic_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket( |
| 6726 | packet_num++, &client_maker1)); |
| 6727 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6728 | mock_quic_data1.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6729 | SYNCHRONOUS, |
| 6730 | ConstructClientRequestHeadersPacket( |
| 6731 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 6732 | &client_maker1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6733 | mock_quic_data1.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6734 | ASYNC, |
| 6735 | ConstructServerResponseHeadersPacket( |
| 6736 | 1, GetNthClientInitiatedBidirectionalStreamId(0), &server_maker1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6737 | mock_quic_data1.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6738 | ASYNC, |
| 6739 | ConstructServerDataPacket( |
| 6740 | 2, GetNthClientInitiatedBidirectionalStreamId(0), &server_maker1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6741 | mock_quic_data1.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6742 | SYNCHRONOUS, |
| 6743 | ConstructClientAckPacket(packet_num++, 2, 1, 1, &client_maker1)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6744 | mock_quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6745 | mock_quic_data1.AddRead(ASYNC, 0); // EOF |
| 6746 | |
| 6747 | mock_quic_data1.AddSocketDataToFactory(&socket_factory_); |
| 6748 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6749 | QuicTestPacketMaker client_maker2( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 6750 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 6751 | &clock_, origin2_, quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6752 | client_headers_include_h2_stream_dependency_); |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 6753 | QuicTestPacketMaker server_maker2( |
| 6754 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 6755 | &clock_, origin2_, quic::Perspective::IS_SERVER, false); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6756 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6757 | MockQuicData mock_quic_data2(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6758 | int packet_num2 = 1; |
| 6759 | if (VersionUsesQpack(version_.transport_version)) { |
| 6760 | mock_quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket( |
| 6761 | packet_num2++, &client_maker2)); |
| 6762 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6763 | mock_quic_data2.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6764 | SYNCHRONOUS, |
| 6765 | ConstructClientRequestHeadersPacket( |
| 6766 | packet_num2++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 6767 | &client_maker2)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6768 | mock_quic_data2.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6769 | ASYNC, |
| 6770 | ConstructServerResponseHeadersPacket( |
| 6771 | 1, GetNthClientInitiatedBidirectionalStreamId(0), &server_maker2)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6772 | mock_quic_data2.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6773 | ASYNC, |
| 6774 | ConstructServerDataPacket( |
| 6775 | 2, GetNthClientInitiatedBidirectionalStreamId(0), &server_maker2)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6776 | mock_quic_data2.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6777 | SYNCHRONOUS, |
| 6778 | ConstructClientAckPacket(packet_num2++, 2, 1, 1, &client_maker2)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6779 | mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6780 | mock_quic_data2.AddRead(ASYNC, 0); // EOF |
| 6781 | |
| 6782 | mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 6783 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6784 | SendRequestAndExpectQuicResponse(origin1_); |
| 6785 | SendRequestAndExpectQuicResponse(origin2_); |
| 6786 | |
| 6787 | EXPECT_TRUE(AllDataConsumed()); |
| 6788 | } |
| 6789 | |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 6790 | // crbug.com/705109 - this confirms that matching request with a body |
| 6791 | // triggers a crash (pre-fix). |
| 6792 | TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) { |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 6793 | session_params_.quic_params.origins_to_force_quic_on.insert( |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 6794 | HostPortPair::FromString("mail.example.org:443")); |
| 6795 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6796 | MockQuicData mock_quic_data(version_); |
Fan Yang | ac86750 | 2019-01-28 21:10:23 | [diff] [blame] | 6797 | uint64_t client_packet_number = 1; |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6798 | if (VersionUsesQpack(version_.transport_version)) { |
| 6799 | mock_quic_data.AddWrite( |
| 6800 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++)); |
| 6801 | } |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6802 | mock_quic_data.AddWrite( |
| 6803 | SYNCHRONOUS, |
| 6804 | ConstructClientRequestHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6805 | client_packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6806 | true, true, GetRequestHeaders("GET", "https", "/"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6807 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6808 | ASYNC, |
| 6809 | ConstructServerPushPromisePacket( |
| 6810 | 1, GetNthClientInitiatedBidirectionalStreamId(0), |
| 6811 | GetNthServerInitiatedUnidirectionalStreamId(0), false, |
| 6812 | GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_maker_)); |
Renjie Tang | 703fea9 | 2019-07-23 21:08:31 | [diff] [blame] | 6813 | |
| 6814 | if ((client_headers_include_h2_stream_dependency_ && |
| 6815 | version_.transport_version >= quic::QUIC_VERSION_43) || |
| 6816 | VersionHasStreamType(version_.transport_version)) { |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6817 | mock_quic_data.AddWrite( |
| 6818 | SYNCHRONOUS, |
| 6819 | ConstructClientPriorityPacket( |
| 6820 | client_packet_number++, false, |
| 6821 | GetNthServerInitiatedUnidirectionalStreamId(0), |
| 6822 | GetNthClientInitiatedBidirectionalStreamId(0), DEFAULT_PRIORITY)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6823 | } |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6824 | mock_quic_data.AddRead( |
| 6825 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6826 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6827 | GetResponseHeaders("200 OK"))); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6828 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6829 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
| 6830 | mock_quic_data.AddRead( |
| 6831 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6832 | 3, GetNthServerInitiatedUnidirectionalStreamId(0), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6833 | false, GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6834 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6835 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6836 | ASYNC, ConstructServerDataPacket( |
| 6837 | 4, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6838 | header + "hello!")); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6839 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6840 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 4, 3, 1)); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 6841 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6842 | std::string header2 = ConstructDataHeader(10); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6843 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6844 | ASYNC, ConstructServerDataPacket( |
| 6845 | 5, GetNthServerInitiatedUnidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6846 | header2 + "and hello!")); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 6847 | |
| 6848 | // Because the matching request has a body, we will see the push |
| 6849 | // stream get cancelled, and the matching request go out on the |
| 6850 | // wire. |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6851 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6852 | ConstructClientAckAndRstPacket( |
| 6853 | client_packet_number++, |
| 6854 | GetNthServerInitiatedUnidirectionalStreamId(0), |
| 6855 | quic::QUIC_STREAM_CANCELLED, 5, 5, 1)); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 6856 | const char kBody[] = "1"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6857 | std::string header3 = ConstructDataHeader(1); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 6858 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 6859 | mock_quic_data.AddWrite( |
| 6860 | SYNCHRONOUS, |
| 6861 | ConstructClientRequestHeadersAndDataFramesPacket( |
| 6862 | client_packet_number++, |
| 6863 | GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
| 6864 | DEFAULT_PRIORITY, GetRequestHeaders("GET", "https", "/pushed.jpg"), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6865 | GetNthServerInitiatedUnidirectionalStreamId(0), nullptr, {kBody})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 6866 | } else { |
| 6867 | mock_quic_data.AddWrite( |
| 6868 | SYNCHRONOUS, |
| 6869 | ConstructClientRequestHeadersAndDataFramesPacket( |
| 6870 | client_packet_number++, |
| 6871 | GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
| 6872 | DEFAULT_PRIORITY, GetRequestHeaders("GET", "https", "/pushed.jpg"), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6873 | GetNthServerInitiatedUnidirectionalStreamId(0), nullptr, |
| 6874 | {header3, kBody})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 6875 | } |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 6876 | |
| 6877 | // We see the same response as for the earlier pushed and cancelled |
| 6878 | // stream. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6879 | mock_quic_data.AddRead( |
| 6880 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6881 | 6, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6882 | GetResponseHeaders("200 OK"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6883 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6884 | ASYNC, ConstructServerDataPacket( |
| 6885 | 7, GetNthClientInitiatedBidirectionalStreamId(1), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6886 | header2 + "and hello!")); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 6887 | |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6888 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6889 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 7, 6, 1)); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 6890 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6891 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6892 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6893 | |
| 6894 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 6895 | // the alternate-protocol job will "win". |
| 6896 | AddHangingNonAlternateProtocolSocketData(); |
| 6897 | |
| 6898 | CreateSession(); |
| 6899 | |
| 6900 | // PUSH_PROMISE handling in the http layer gets exercised here. |
| 6901 | SendRequestAndExpectQuicResponse("hello!"); |
| 6902 | |
| 6903 | request_.url = GURL("https://mail.example.org/pushed.jpg"); |
| 6904 | ChunkedUploadDataStream upload_data(0); |
| 6905 | upload_data.AppendData("1", 1, true); |
| 6906 | request_.upload_data_stream = &upload_data; |
| 6907 | SendRequestAndExpectQuicResponse("and hello!"); |
| 6908 | } |
| 6909 | |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6910 | // Regression test for https://crbug.com/797825: If pushed headers describe a |
| 6911 | // valid URL with empty hostname, then X509Certificate::VerifyHostname() must |
| 6912 | // not be called (otherwise a DCHECK fails). |
| 6913 | TEST_P(QuicNetworkTransactionTest, QuicServerPushWithEmptyHostname) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6914 | spdy::SpdyHeaderBlock pushed_request_headers; |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6915 | pushed_request_headers[":authority"] = ""; |
| 6916 | pushed_request_headers[":method"] = "GET"; |
| 6917 | pushed_request_headers[":path"] = "/"; |
| 6918 | pushed_request_headers[":scheme"] = "nosuchscheme"; |
| 6919 | |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 6920 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6921 | HostPortPair::FromString("mail.example.org:443")); |
| 6922 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6923 | MockQuicData mock_quic_data(version_); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6924 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6925 | int packet_num = 1; |
| 6926 | if (VersionUsesQpack(version_.transport_version)) { |
| 6927 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6928 | ConstructInitialSettingsPacket(packet_num++)); |
| 6929 | } |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6930 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6931 | SYNCHRONOUS, |
| 6932 | ConstructClientRequestHeadersPacket( |
| 6933 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 6934 | true, GetRequestHeaders("GET", "https", "/"))); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6935 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6936 | mock_quic_data.AddRead( |
| 6937 | ASYNC, ConstructServerPushPromisePacket( |
| 6938 | 1, GetNthClientInitiatedBidirectionalStreamId(0), |
| 6939 | GetNthServerInitiatedUnidirectionalStreamId(0), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6940 | std::move(pushed_request_headers), &server_maker_)); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6941 | mock_quic_data.AddWrite( |
| 6942 | SYNCHRONOUS, |
| 6943 | ConstructClientRstPacket(packet_num++, |
| 6944 | GetNthServerInitiatedUnidirectionalStreamId(0), |
| 6945 | quic::QUIC_INVALID_PROMISE_URL)); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6946 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6947 | mock_quic_data.AddRead( |
| 6948 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6949 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6950 | GetResponseHeaders("200 OK"))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6951 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6952 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6953 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6954 | mock_quic_data.AddRead( |
| 6955 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6956 | 3, GetNthServerInitiatedUnidirectionalStreamId(0), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 6957 | false, GetResponseHeaders("200 OK"))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 6958 | std::string header = ConstructDataHeader(6); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6959 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6960 | ASYNC, ConstructServerDataPacket( |
| 6961 | 4, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 6962 | header + "hello!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6963 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6964 | ConstructClientAckPacket(packet_num++, 4, 3, 1)); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 6965 | |
| 6966 | mock_quic_data.AddRead(ASYNC, 0); |
| 6967 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6968 | |
| 6969 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 6970 | // the alternate-protocol job will "win". |
| 6971 | AddHangingNonAlternateProtocolSocketData(); |
| 6972 | |
| 6973 | CreateSession(); |
| 6974 | |
| 6975 | // PUSH_PROMISE handling in the http layer gets exercised here. |
| 6976 | SendRequestAndExpectQuicResponse("hello!"); |
| 6977 | |
| 6978 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 6979 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 6980 | } |
| 6981 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 6982 | // Performs an HTTPS/1.1 request over QUIC proxy tunnel. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 6983 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectHttpsServer) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 6984 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 6985 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 6986 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 6987 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 6988 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 6989 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6990 | int packet_num = 1; |
| 6991 | if (VersionUsesQpack(version_.transport_version)) { |
| 6992 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6993 | ConstructInitialSettingsPacket(packet_num++)); |
| 6994 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 6995 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 6996 | SYNCHRONOUS, |
| 6997 | ConstructClientRequestHeadersPacket( |
| 6998 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 6999 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7000 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7001 | mock_quic_data.AddRead( |
| 7002 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7003 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 7004 | GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7005 | |
| 7006 | const char get_request[] = |
| 7007 | "GET / HTTP/1.1\r\n" |
| 7008 | "Host: mail.example.org\r\n" |
| 7009 | "Connection: keep-alive\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7010 | std::string header = ConstructDataHeader(strlen(get_request)); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 7011 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7012 | mock_quic_data.AddWrite( |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7013 | SYNCHRONOUS, |
| 7014 | ConstructClientAckAndDataPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7015 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7016 | 1, 1, 1, false, quic::QuicStringPiece(get_request))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7017 | } else { |
| 7018 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7019 | SYNCHRONOUS, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7020 | ConstructClientAckAndMultipleDataFramesPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7021 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7022 | 1, 1, 1, false, {header, std::string(get_request)})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7023 | } |
| 7024 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7025 | const char get_response[] = |
| 7026 | "HTTP/1.1 200 OK\r\n" |
| 7027 | "Content-Length: 10\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7028 | std::string header2 = ConstructDataHeader(strlen(get_response)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7029 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7030 | ASYNC, ConstructServerDataPacket( |
| 7031 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7032 | header2 + std::string(get_response))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7033 | std::string header3 = ConstructDataHeader(10); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7034 | mock_quic_data.AddRead( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7035 | SYNCHRONOUS, ConstructServerDataPacket( |
| 7036 | 3, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7037 | false, header3 + std::string("0123456789"))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7038 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7039 | ConstructClientAckPacket(packet_num++, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7040 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7041 | |
| 7042 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7043 | SYNCHRONOUS, |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7044 | ConstructClientRstPacket(packet_num++, |
| 7045 | GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 7046 | quic::QUIC_STREAM_CANCELLED)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7047 | |
| 7048 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7049 | |
| 7050 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7051 | |
| 7052 | CreateSession(); |
| 7053 | |
| 7054 | request_.url = GURL("https://mail.example.org/"); |
Brad Lassey | e62461e | 2018-12-13 04:21:09 | [diff] [blame] | 7055 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7056 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7057 | HeadersHandler headers_handler; |
| 7058 | trans.SetBeforeHeadersSentCallback( |
| 7059 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7060 | base::Unretained(&headers_handler))); |
| 7061 | RunTransaction(&trans); |
| 7062 | CheckWasHttpResponse(&trans); |
| 7063 | CheckResponsePort(&trans, 70); |
| 7064 | CheckResponseData(&trans, "0123456789"); |
| 7065 | EXPECT_TRUE(headers_handler.was_proxied()); |
| 7066 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 7067 | |
| 7068 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7069 | // proxy socket to disconnect. |
| 7070 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7071 | |
| 7072 | base::RunLoop().RunUntilIdle(); |
| 7073 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7074 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7075 | } |
| 7076 | |
| 7077 | // Performs an HTTP/2 request over QUIC proxy tunnel. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7078 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectSpdyServer) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7079 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7080 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7081 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7082 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7083 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7084 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7085 | int packet_num = 1; |
| 7086 | if (VersionUsesQpack(version_.transport_version)) { |
| 7087 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7088 | ConstructInitialSettingsPacket(packet_num++)); |
| 7089 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7090 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7091 | SYNCHRONOUS, |
| 7092 | ConstructClientRequestHeadersPacket( |
| 7093 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7094 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7095 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7096 | mock_quic_data.AddRead( |
| 7097 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7098 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 7099 | GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7100 | |
| 7101 | SpdyTestUtil spdy_util; |
| 7102 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7103 | spdy::SpdySerializedFrame get_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7104 | spdy_util.ConstructSpdyGet("https://mail.example.org/", 1, LOWEST); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7105 | std::string header = ConstructDataHeader(get_frame.size()); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 7106 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7107 | mock_quic_data.AddWrite( |
| 7108 | SYNCHRONOUS, |
| 7109 | ConstructClientAckAndDataPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7110 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7111 | 1, 1, 1, false, |
| 7112 | quic::QuicStringPiece(get_frame.data(), get_frame.size()))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7113 | } else { |
| 7114 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7115 | SYNCHRONOUS, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7116 | ConstructClientAckAndMultipleDataFramesPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7117 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7118 | 1, 1, 1, false, |
| 7119 | {header, std::string(get_frame.data(), get_frame.size())})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7120 | } |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7121 | spdy::SpdySerializedFrame resp_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7122 | spdy_util.ConstructSpdyGetReply(nullptr, 0, 1); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7123 | std::string header2 = ConstructDataHeader(resp_frame.size()); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7124 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7125 | ASYNC, ConstructServerDataPacket( |
| 7126 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 7127 | header2 + std::string(resp_frame.data(), resp_frame.size()))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7128 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7129 | spdy::SpdySerializedFrame data_frame = |
Bence Béky | d74f438 | 2018-02-20 18:26:19 | [diff] [blame] | 7130 | spdy_util.ConstructSpdyDataFrame(1, "0123456789", true); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7131 | std::string header3 = ConstructDataHeader(resp_frame.size()); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7132 | mock_quic_data.AddRead( |
| 7133 | SYNCHRONOUS, |
| 7134 | ConstructServerDataPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7135 | 3, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7136 | header3 + std::string(data_frame.data(), data_frame.size()))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7137 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7138 | ConstructClientAckPacket(packet_num++, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7139 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7140 | |
| 7141 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7142 | SYNCHRONOUS, |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7143 | ConstructClientRstPacket(packet_num++, |
| 7144 | GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 7145 | quic::QUIC_STREAM_CANCELLED)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7146 | |
| 7147 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7148 | |
| 7149 | SSLSocketDataProvider ssl_data(ASYNC, OK); |
| 7150 | ssl_data.next_proto = kProtoHTTP2; |
| 7151 | socket_factory_.AddSSLSocketDataProvider(&ssl_data); |
| 7152 | |
| 7153 | CreateSession(); |
| 7154 | |
| 7155 | request_.url = GURL("https://mail.example.org/"); |
| 7156 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7157 | HeadersHandler headers_handler; |
| 7158 | trans.SetBeforeHeadersSentCallback( |
| 7159 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7160 | base::Unretained(&headers_handler))); |
| 7161 | RunTransaction(&trans); |
| 7162 | CheckWasSpdyResponse(&trans); |
| 7163 | CheckResponsePort(&trans, 70); |
| 7164 | CheckResponseData(&trans, "0123456789"); |
| 7165 | EXPECT_TRUE(headers_handler.was_proxied()); |
| 7166 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 7167 | |
Wez | 0e71711 | 2018-06-18 23:09:22 | [diff] [blame] | 7168 | // Causes MockSSLClientSocket to disconproxyconnecthttpnect, which causes the |
| 7169 | // underlying QUIC proxy socket to disconnect. |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7170 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7171 | |
| 7172 | base::RunLoop().RunUntilIdle(); |
| 7173 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7174 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7175 | } |
| 7176 | |
| 7177 | // Make two HTTP/1.1 requests to the same host over a QUIC proxy tunnel and |
| 7178 | // check that the proxy socket is reused for the second request. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7179 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseTransportSocket) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7180 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7181 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7182 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7183 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7184 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7185 | MockQuicData mock_quic_data(version_); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7186 | int write_packet_index = 1; |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7187 | if (VersionUsesQpack(version_.transport_version)) { |
| 7188 | mock_quic_data.AddWrite( |
| 7189 | SYNCHRONOUS, ConstructInitialSettingsPacket(write_packet_index++)); |
| 7190 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7191 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7192 | SYNCHRONOUS, |
| 7193 | ConstructClientRequestHeadersPacket( |
| 7194 | write_packet_index++, GetNthClientInitiatedBidirectionalStreamId(0), |
Matt Menke | 6e879bd | 2019-03-18 17:26:04 | [diff] [blame] | 7195 | true, false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7196 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7197 | mock_quic_data.AddRead( |
| 7198 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7199 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 7200 | GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7201 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7202 | quic::QuicStreamOffset server_data_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7203 | const char get_request_1[] = |
| 7204 | "GET / HTTP/1.1\r\n" |
| 7205 | "Host: mail.example.org\r\n" |
| 7206 | "Connection: keep-alive\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7207 | std::string header = ConstructDataHeader(strlen(get_request_1)); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 7208 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7209 | mock_quic_data.AddWrite( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7210 | SYNCHRONOUS, ConstructClientAckAndDataPacket( |
| 7211 | write_packet_index++, false, |
| 7212 | GetNthClientInitiatedBidirectionalStreamId(0), 1, 1, 1, |
| 7213 | false, quic::QuicStringPiece(get_request_1))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7214 | } else { |
| 7215 | mock_quic_data.AddWrite( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7216 | SYNCHRONOUS, ConstructClientAckAndMultipleDataFramesPacket( |
| 7217 | write_packet_index++, false, |
| 7218 | GetNthClientInitiatedBidirectionalStreamId(0), 1, 1, 1, |
| 7219 | false, {header, std::string(get_request_1)})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7220 | } |
| 7221 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7222 | const char get_response_1[] = |
| 7223 | "HTTP/1.1 200 OK\r\n" |
| 7224 | "Content-Length: 10\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7225 | std::string header2 = ConstructDataHeader(strlen(get_response_1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7226 | mock_quic_data.AddRead( |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7227 | ASYNC, ConstructServerDataPacket( |
| 7228 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7229 | header2 + std::string(get_response_1))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7230 | server_data_offset += strlen(get_response_1) + header2.length(); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7231 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7232 | std::string header3 = ConstructDataHeader(10); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7233 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7234 | SYNCHRONOUS, ConstructServerDataPacket( |
| 7235 | 3, GetNthClientInitiatedBidirectionalStreamId(0), false, |
| 7236 | false, header3 + std::string("0123456789"))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7237 | server_data_offset += 10 + header3.length(); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7238 | |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7239 | mock_quic_data.AddWrite( |
| 7240 | SYNCHRONOUS, ConstructClientAckPacket(write_packet_index++, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7241 | |
| 7242 | const char get_request_2[] = |
| 7243 | "GET /2 HTTP/1.1\r\n" |
| 7244 | "Host: mail.example.org\r\n" |
| 7245 | "Connection: keep-alive\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7246 | std::string header4 = ConstructDataHeader(strlen(get_request_2)); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 7247 | if (version_.transport_version == quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7248 | mock_quic_data.AddWrite( |
| 7249 | SYNCHRONOUS, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7250 | ConstructClientMultipleDataFramesPacket( |
| 7251 | write_packet_index++, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7252 | false, false, {header4, std::string(get_request_2)})); |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7253 | } else { |
| 7254 | mock_quic_data.AddWrite( |
| 7255 | SYNCHRONOUS, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7256 | ConstructClientDataPacket( |
| 7257 | write_packet_index++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7258 | false, false, quic::QuicStringPiece(get_request_2))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7259 | } |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7260 | |
| 7261 | const char get_response_2[] = |
| 7262 | "HTTP/1.1 200 OK\r\n" |
| 7263 | "Content-Length: 7\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7264 | std::string header5 = ConstructDataHeader(strlen(get_response_2)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7265 | mock_quic_data.AddRead( |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7266 | ASYNC, ConstructServerDataPacket( |
| 7267 | 4, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7268 | header5 + std::string(get_response_2))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7269 | server_data_offset += strlen(get_response_2) + header5.length(); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7270 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7271 | std::string header6 = ConstructDataHeader(7); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7272 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7273 | SYNCHRONOUS, ConstructServerDataPacket( |
| 7274 | 5, GetNthClientInitiatedBidirectionalStreamId(0), false, |
| 7275 | false, header6 + std::string("0123456"))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7276 | server_data_offset += 7 + header6.length(); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7277 | |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7278 | mock_quic_data.AddWrite( |
| 7279 | SYNCHRONOUS, ConstructClientAckPacket(write_packet_index++, 5, 4, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7280 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7281 | |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7282 | mock_quic_data.AddWrite( |
| 7283 | SYNCHRONOUS, |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 7284 | ConstructClientRstPacket(write_packet_index++, |
| 7285 | GetNthClientInitiatedBidirectionalStreamId(0), |
| 7286 | quic::QUIC_STREAM_CANCELLED)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7287 | |
| 7288 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7289 | |
| 7290 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7291 | |
| 7292 | CreateSession(); |
| 7293 | |
| 7294 | request_.url = GURL("https://mail.example.org/"); |
| 7295 | HttpNetworkTransaction trans_1(DEFAULT_PRIORITY, session_.get()); |
| 7296 | HeadersHandler headers_handler_1; |
| 7297 | trans_1.SetBeforeHeadersSentCallback( |
| 7298 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7299 | base::Unretained(&headers_handler_1))); |
| 7300 | RunTransaction(&trans_1); |
| 7301 | CheckWasHttpResponse(&trans_1); |
| 7302 | CheckResponsePort(&trans_1, 70); |
| 7303 | CheckResponseData(&trans_1, "0123456789"); |
| 7304 | EXPECT_TRUE(headers_handler_1.was_proxied()); |
| 7305 | EXPECT_TRUE(trans_1.GetResponseInfo()->proxy_server.is_quic()); |
| 7306 | |
| 7307 | request_.url = GURL("https://mail.example.org/2"); |
| 7308 | HttpNetworkTransaction trans_2(DEFAULT_PRIORITY, session_.get()); |
| 7309 | HeadersHandler headers_handler_2; |
| 7310 | trans_2.SetBeforeHeadersSentCallback( |
| 7311 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7312 | base::Unretained(&headers_handler_2))); |
| 7313 | RunTransaction(&trans_2); |
| 7314 | CheckWasHttpResponse(&trans_2); |
| 7315 | CheckResponsePort(&trans_2, 70); |
| 7316 | CheckResponseData(&trans_2, "0123456"); |
| 7317 | EXPECT_TRUE(headers_handler_2.was_proxied()); |
| 7318 | EXPECT_TRUE(trans_2.GetResponseInfo()->proxy_server.is_quic()); |
| 7319 | |
| 7320 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7321 | // proxy socket to disconnect. |
| 7322 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7323 | |
| 7324 | base::RunLoop().RunUntilIdle(); |
| 7325 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7326 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7327 | } |
| 7328 | |
| 7329 | // Make an HTTP/1.1 request to one host and an HTTP/2 request to a different |
| 7330 | // host over a QUIC proxy tunnel. Check that the QUIC session to the proxy |
| 7331 | // server is reused for the second request. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7332 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseQuicSession) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7333 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7334 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7335 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7336 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7337 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7338 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7339 | int packet_num = 1; |
| 7340 | if (VersionUsesQpack(version_.transport_version)) { |
| 7341 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7342 | ConstructInitialSettingsPacket(packet_num++)); |
| 7343 | } |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7344 | |
| 7345 | // CONNECT request and response for first request |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7346 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7347 | SYNCHRONOUS, |
| 7348 | ConstructClientRequestHeadersPacket( |
| 7349 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7350 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7351 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7352 | mock_quic_data.AddRead( |
| 7353 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7354 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7355 | GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7356 | |
| 7357 | // GET request, response, and data over QUIC tunnel for first request |
| 7358 | const char get_request[] = |
| 7359 | "GET / HTTP/1.1\r\n" |
| 7360 | "Host: mail.example.org\r\n" |
| 7361 | "Connection: keep-alive\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7362 | std::string header = ConstructDataHeader(strlen(get_request)); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 7363 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7364 | mock_quic_data.AddWrite( |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7365 | SYNCHRONOUS, |
| 7366 | ConstructClientAckAndDataPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7367 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7368 | 1, 1, 1, false, quic::QuicStringPiece(get_request))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7369 | } else { |
| 7370 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7371 | SYNCHRONOUS, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7372 | ConstructClientAckAndMultipleDataFramesPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7373 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7374 | 1, 1, 1, false, {header, std::string(get_request)})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7375 | } |
| 7376 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7377 | const char get_response[] = |
| 7378 | "HTTP/1.1 200 OK\r\n" |
| 7379 | "Content-Length: 10\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7380 | std::string header2 = ConstructDataHeader(strlen(get_response)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7381 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7382 | ASYNC, ConstructServerDataPacket( |
| 7383 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7384 | header2 + std::string(get_response))); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7385 | std::string header3 = ConstructDataHeader(10); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7386 | mock_quic_data.AddRead( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7387 | SYNCHRONOUS, ConstructServerDataPacket( |
| 7388 | 3, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7389 | false, header3 + std::string("0123456789"))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7390 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7391 | ConstructClientAckPacket(packet_num++, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7392 | |
| 7393 | // CONNECT request and response for second request |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7394 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7395 | SYNCHRONOUS, |
| 7396 | ConstructClientRequestHeadersPacket( |
| 7397 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 7398 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7399 | ConnectRequestHeaders("different.example.org:443"), |
| 7400 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7401 | mock_quic_data.AddRead( |
| 7402 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7403 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7404 | GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7405 | |
| 7406 | // GET request, response, and data over QUIC tunnel for second request |
| 7407 | SpdyTestUtil spdy_util; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7408 | spdy::SpdySerializedFrame get_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7409 | spdy_util.ConstructSpdyGet("https://different.example.org/", 1, LOWEST); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7410 | std::string header4 = ConstructDataHeader(get_frame.size()); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 7411 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7412 | mock_quic_data.AddWrite( |
| 7413 | SYNCHRONOUS, |
| 7414 | ConstructClientAckAndDataPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7415 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(1), |
| 7416 | 4, 4, 1, false, |
| 7417 | quic::QuicStringPiece(get_frame.data(), get_frame.size()))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7418 | } else { |
| 7419 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7420 | SYNCHRONOUS, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7421 | ConstructClientAckAndMultipleDataFramesPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7422 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(1), |
| 7423 | 4, 4, 1, false, |
| 7424 | {header4, std::string(get_frame.data(), get_frame.size())})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7425 | } |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7426 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7427 | spdy::SpdySerializedFrame resp_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7428 | spdy_util.ConstructSpdyGetReply(nullptr, 0, 1); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7429 | std::string header5 = ConstructDataHeader(resp_frame.size()); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7430 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7431 | ASYNC, ConstructServerDataPacket( |
| 7432 | 5, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
| 7433 | header5 + std::string(resp_frame.data(), resp_frame.size()))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7434 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7435 | spdy::SpdySerializedFrame data_frame = |
Bence Béky | d74f438 | 2018-02-20 18:26:19 | [diff] [blame] | 7436 | spdy_util.ConstructSpdyDataFrame(1, "0123456", true); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7437 | std::string header6 = ConstructDataHeader(data_frame.size()); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7438 | mock_quic_data.AddRead( |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7439 | ASYNC, ConstructServerDataPacket( |
| 7440 | 6, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7441 | header6 + std::string(data_frame.data(), data_frame.size()))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7442 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7443 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7444 | ConstructClientAckPacket(packet_num++, 6, 5, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7445 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7446 | |
| 7447 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7448 | SYNCHRONOUS, |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7449 | ConstructClientRstPacket(packet_num++, |
| 7450 | GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 7451 | quic::QUIC_STREAM_CANCELLED)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7452 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7453 | SYNCHRONOUS, |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7454 | ConstructClientRstPacket(packet_num++, |
| 7455 | GetNthClientInitiatedBidirectionalStreamId(1), |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 7456 | quic::QUIC_STREAM_CANCELLED)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7457 | |
| 7458 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7459 | |
| 7460 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7461 | |
| 7462 | SSLSocketDataProvider ssl_data(ASYNC, OK); |
| 7463 | ssl_data.next_proto = kProtoHTTP2; |
| 7464 | socket_factory_.AddSSLSocketDataProvider(&ssl_data); |
| 7465 | |
| 7466 | CreateSession(); |
| 7467 | |
| 7468 | request_.url = GURL("https://mail.example.org/"); |
| 7469 | HttpNetworkTransaction trans_1(DEFAULT_PRIORITY, session_.get()); |
| 7470 | HeadersHandler headers_handler_1; |
| 7471 | trans_1.SetBeforeHeadersSentCallback( |
| 7472 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7473 | base::Unretained(&headers_handler_1))); |
| 7474 | RunTransaction(&trans_1); |
| 7475 | CheckWasHttpResponse(&trans_1); |
| 7476 | CheckResponsePort(&trans_1, 70); |
| 7477 | CheckResponseData(&trans_1, "0123456789"); |
| 7478 | EXPECT_TRUE(headers_handler_1.was_proxied()); |
| 7479 | EXPECT_TRUE(trans_1.GetResponseInfo()->proxy_server.is_quic()); |
| 7480 | |
| 7481 | request_.url = GURL("https://different.example.org/"); |
| 7482 | HttpNetworkTransaction trans_2(DEFAULT_PRIORITY, session_.get()); |
| 7483 | HeadersHandler headers_handler_2; |
| 7484 | trans_2.SetBeforeHeadersSentCallback( |
| 7485 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7486 | base::Unretained(&headers_handler_2))); |
| 7487 | RunTransaction(&trans_2); |
| 7488 | CheckWasSpdyResponse(&trans_2); |
| 7489 | CheckResponsePort(&trans_2, 70); |
| 7490 | CheckResponseData(&trans_2, "0123456"); |
| 7491 | EXPECT_TRUE(headers_handler_2.was_proxied()); |
| 7492 | EXPECT_TRUE(trans_2.GetResponseInfo()->proxy_server.is_quic()); |
| 7493 | |
| 7494 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7495 | // proxy socket to disconnect. |
| 7496 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7497 | |
| 7498 | base::RunLoop().RunUntilIdle(); |
| 7499 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7500 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7501 | } |
| 7502 | |
| 7503 | // Sends a CONNECT request to a QUIC proxy and receive a 500 response. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7504 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectFailure) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7505 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7506 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7507 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7508 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7509 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7510 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7511 | int packet_num = 1; |
| 7512 | if (VersionUsesQpack(version_.transport_version)) { |
| 7513 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7514 | ConstructInitialSettingsPacket(packet_num++)); |
| 7515 | } |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7516 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7517 | SYNCHRONOUS, |
| 7518 | ConstructClientRequestHeadersPacket( |
| 7519 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7520 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7521 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7522 | mock_quic_data.AddRead( |
| 7523 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7524 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, true, |
| 7525 | GetResponseHeaders("500"))); |
| 7526 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7527 | mock_quic_data.AddWrite( |
| 7528 | SYNCHRONOUS, |
| 7529 | ConstructClientAckAndRstPacket( |
| 7530 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7531 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7532 | |
| 7533 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7534 | |
| 7535 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7536 | |
| 7537 | CreateSession(); |
| 7538 | |
| 7539 | request_.url = GURL("https://mail.example.org/"); |
| 7540 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7541 | HeadersHandler headers_handler; |
| 7542 | trans.SetBeforeHeadersSentCallback( |
| 7543 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7544 | base::Unretained(&headers_handler))); |
| 7545 | TestCompletionCallback callback; |
| 7546 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7547 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7548 | EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback.WaitForResult()); |
| 7549 | EXPECT_EQ(false, headers_handler.was_proxied()); |
| 7550 | |
| 7551 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7552 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7553 | } |
| 7554 | |
| 7555 | // Sends a CONNECT request to a QUIC proxy and get a UDP socket read error. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7556 | TEST_P(QuicNetworkTransactionTest, QuicProxyQuicConnectionError) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7557 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7558 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7559 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7560 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7561 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7562 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7563 | int packet_num = 1; |
| 7564 | if (VersionUsesQpack(version_.transport_version)) { |
| 7565 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7566 | ConstructInitialSettingsPacket(packet_num++)); |
| 7567 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7568 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7569 | SYNCHRONOUS, |
| 7570 | ConstructClientRequestHeadersPacket( |
| 7571 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7572 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7573 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7574 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_FAILED); |
| 7575 | |
| 7576 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7577 | |
| 7578 | CreateSession(); |
| 7579 | |
| 7580 | request_.url = GURL("https://mail.example.org/"); |
| 7581 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7582 | HeadersHandler headers_handler; |
| 7583 | trans.SetBeforeHeadersSentCallback( |
| 7584 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7585 | base::Unretained(&headers_handler))); |
| 7586 | TestCompletionCallback callback; |
| 7587 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7588 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7589 | EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback.WaitForResult()); |
| 7590 | |
| 7591 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7592 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7593 | } |
| 7594 | |
| 7595 | // Sends an HTTP/1.1 request over QUIC proxy tunnel and gets a bad cert from the |
| 7596 | // host. Retries request and succeeds. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7597 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectBadCertificate) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7598 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7599 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7600 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7601 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7602 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7603 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7604 | int packet_num = 1; |
| 7605 | if (VersionUsesQpack(version_.transport_version)) { |
| 7606 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7607 | ConstructInitialSettingsPacket(packet_num++)); |
| 7608 | } |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7609 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7610 | SYNCHRONOUS, |
| 7611 | ConstructClientRequestHeadersPacket( |
| 7612 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7613 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7614 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7615 | mock_quic_data.AddRead( |
| 7616 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7617 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7618 | GetResponseHeaders("200 OK"))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7619 | mock_quic_data.AddWrite( |
| 7620 | SYNCHRONOUS, |
| 7621 | ConstructClientAckAndRstPacket( |
| 7622 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 7623 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7624 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7625 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7626 | SYNCHRONOUS, |
| 7627 | ConstructClientRequestHeadersPacket( |
| 7628 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 7629 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7630 | ConnectRequestHeaders("mail.example.org:443"), |
| 7631 | GetNthClientInitiatedBidirectionalStreamId(0))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7632 | mock_quic_data.AddRead( |
| 7633 | ASYNC, ConstructServerResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7634 | 2, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7635 | GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7636 | |
| 7637 | const char get_request[] = |
| 7638 | "GET / HTTP/1.1\r\n" |
| 7639 | "Host: mail.example.org\r\n" |
| 7640 | "Connection: keep-alive\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7641 | std::string header = ConstructDataHeader(strlen(get_request)); |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 7642 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7643 | mock_quic_data.AddWrite( |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7644 | SYNCHRONOUS, |
| 7645 | ConstructClientAckAndDataPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7646 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(1), |
| 7647 | 2, 2, 1, false, quic::QuicStringPiece(get_request))); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7648 | } else { |
| 7649 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7650 | SYNCHRONOUS, |
Renjie | d172e81 | 2019-01-16 05:12:35 | [diff] [blame] | 7651 | ConstructClientAckAndMultipleDataFramesPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7652 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(1), |
| 7653 | 2, 2, 1, false, {header, std::string(get_request)})); |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7654 | } |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7655 | const char get_response[] = |
| 7656 | "HTTP/1.1 200 OK\r\n" |
| 7657 | "Content-Length: 10\r\n\r\n"; |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7658 | std::string header2 = ConstructDataHeader(strlen(get_response)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7659 | mock_quic_data.AddRead( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7660 | ASYNC, ConstructServerDataPacket( |
| 7661 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7662 | header2 + std::string(get_response))); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7663 | |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 7664 | std::string header3 = ConstructDataHeader(10); |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7665 | mock_quic_data.AddRead( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7666 | SYNCHRONOUS, ConstructServerDataPacket( |
| 7667 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7668 | false, header3 + std::string("0123456789"))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7669 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7670 | ConstructClientAckPacket(packet_num++, 4, 3, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7671 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7672 | |
| 7673 | mock_quic_data.AddWrite( |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 7674 | SYNCHRONOUS, |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7675 | ConstructClientRstPacket(packet_num++, |
| 7676 | GetNthClientInitiatedBidirectionalStreamId(1), |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 7677 | quic::QUIC_STREAM_CANCELLED)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7678 | |
| 7679 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7680 | |
| 7681 | SSLSocketDataProvider ssl_data_bad_cert(ASYNC, ERR_CERT_AUTHORITY_INVALID); |
| 7682 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_bad_cert); |
| 7683 | |
| 7684 | SSLSocketDataProvider ssl_data(ASYNC, OK); |
| 7685 | socket_factory_.AddSSLSocketDataProvider(&ssl_data); |
| 7686 | |
| 7687 | CreateSession(); |
| 7688 | |
| 7689 | request_.url = GURL("https://mail.example.org/"); |
| 7690 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7691 | HeadersHandler headers_handler; |
| 7692 | trans.SetBeforeHeadersSentCallback( |
| 7693 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7694 | base::Unretained(&headers_handler))); |
| 7695 | TestCompletionCallback callback; |
| 7696 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7697 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7698 | EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, callback.WaitForResult()); |
| 7699 | |
| 7700 | rv = trans.RestartIgnoringLastError(callback.callback()); |
| 7701 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7702 | EXPECT_EQ(OK, callback.WaitForResult()); |
| 7703 | |
| 7704 | CheckWasHttpResponse(&trans); |
| 7705 | CheckResponsePort(&trans, 70); |
| 7706 | CheckResponseData(&trans, "0123456789"); |
| 7707 | EXPECT_EQ(true, headers_handler.was_proxied()); |
| 7708 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 7709 | |
| 7710 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7711 | // proxy socket to disconnect. |
| 7712 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7713 | |
| 7714 | base::RunLoop().RunUntilIdle(); |
| 7715 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7716 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7717 | } |
| 7718 | |
| 7719 | // Checks if a request's specified "user-agent" header shows up correctly in the |
| 7720 | // CONNECT request to a QUIC proxy. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7721 | TEST_P(QuicNetworkTransactionTest, QuicProxyUserAgent) { |
Matt Menke | d732ea4 | 2019-03-08 12:05:00 | [diff] [blame] | 7722 | const char kConfiguredUserAgent[] = "Configured User-Agent"; |
| 7723 | const char kRequestUserAgent[] = "Request User-Agent"; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7724 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7725 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7726 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7727 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7728 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7729 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7730 | int packet_num = 1; |
| 7731 | if (VersionUsesQpack(version_.transport_version)) { |
| 7732 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7733 | ConstructInitialSettingsPacket(packet_num++)); |
| 7734 | } |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7735 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7736 | spdy::SpdyHeaderBlock headers = ConnectRequestHeaders("mail.example.org:443"); |
Matt Menke | d732ea4 | 2019-03-08 12:05:00 | [diff] [blame] | 7737 | headers["user-agent"] = kConfiguredUserAgent; |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7738 | mock_quic_data.AddWrite( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7739 | SYNCHRONOUS, |
| 7740 | ConstructClientRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7741 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7742 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, std::move(headers), |
| 7743 | 0)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7744 | // Return an error, so the transaction stops here (this test isn't interested |
| 7745 | // in the rest). |
| 7746 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_FAILED); |
| 7747 | |
| 7748 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7749 | |
Matt Menke | d732ea4 | 2019-03-08 12:05:00 | [diff] [blame] | 7750 | StaticHttpUserAgentSettings http_user_agent_settings( |
| 7751 | std::string() /* accept_language */, kConfiguredUserAgent); |
| 7752 | session_context_.http_user_agent_settings = &http_user_agent_settings; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7753 | CreateSession(); |
| 7754 | |
| 7755 | request_.url = GURL("https://mail.example.org/"); |
| 7756 | request_.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent, |
Matt Menke | d732ea4 | 2019-03-08 12:05:00 | [diff] [blame] | 7757 | kRequestUserAgent); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7758 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7759 | HeadersHandler headers_handler; |
| 7760 | trans.SetBeforeHeadersSentCallback( |
| 7761 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7762 | base::Unretained(&headers_handler))); |
| 7763 | TestCompletionCallback callback; |
| 7764 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7765 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7766 | EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback.WaitForResult()); |
| 7767 | |
| 7768 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7769 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7770 | } |
| 7771 | |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7772 | // Makes sure the CONNECT request packet for a QUIC proxy contains the correct |
| 7773 | // HTTP/2 stream dependency and weights given the request priority. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7774 | TEST_P(QuicNetworkTransactionTest, QuicProxyRequestPriority) { |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7775 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7776 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7777 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7778 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7779 | |
| 7780 | const RequestPriority request_priority = MEDIUM; |
| 7781 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7782 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7783 | int packet_num = 1; |
| 7784 | if (VersionUsesQpack(version_.transport_version)) { |
| 7785 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7786 | ConstructInitialSettingsPacket(packet_num++)); |
| 7787 | } |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7788 | mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7789 | SYNCHRONOUS, |
| 7790 | ConstructClientRequestHeadersPacket( |
| 7791 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7792 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7793 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7794 | // Return an error, so the transaction stops here (this test isn't interested |
| 7795 | // in the rest). |
| 7796 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_FAILED); |
| 7797 | |
| 7798 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7799 | |
| 7800 | CreateSession(); |
| 7801 | |
| 7802 | request_.url = GURL("https://mail.example.org/"); |
| 7803 | HttpNetworkTransaction trans(request_priority, session_.get()); |
| 7804 | TestCompletionCallback callback; |
| 7805 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7806 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7807 | EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback.WaitForResult()); |
| 7808 | |
| 7809 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7810 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7811 | } |
| 7812 | |
Matt Menke | edaf3b8 | 2019-03-14 21:39:44 | [diff] [blame] | 7813 | // Makes sure the CONNECT request packet for a QUIC proxy contains the correct |
| 7814 | // HTTP/2 stream dependency and weights given the request priority. |
| 7815 | TEST_P(QuicNetworkTransactionTest, QuicProxyMultipleRequestsError) { |
| 7816 | session_params_.enable_quic = true; |
| 7817 | session_params_.enable_quic_proxies_for_https_urls = true; |
| 7818 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| 7819 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
| 7820 | |
| 7821 | const RequestPriority kRequestPriority = MEDIUM; |
| 7822 | const RequestPriority kRequestPriority2 = LOWEST; |
| 7823 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7824 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7825 | if (VersionUsesQpack(version_.transport_version)) { |
| 7826 | mock_quic_data.AddWrite(ASYNC, ConstructInitialSettingsPacket(1)); |
| 7827 | mock_quic_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
| 7828 | } else { |
| 7829 | mock_quic_data.AddWrite( |
| 7830 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 7831 | 1, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7832 | false, HttpProxyConnectJob::kH2QuicTunnelPriority, |
| 7833 | ConnectRequestHeaders("mail.example.org:443"), 0)); |
| 7834 | } |
Matt Menke | edaf3b8 | 2019-03-14 21:39:44 | [diff] [blame] | 7835 | // This should never be reached. |
| 7836 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_FAILED); |
| 7837 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7838 | |
| 7839 | // Second connection attempt just fails - result doesn't really matter. |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7840 | MockQuicData mock_quic_data2(version_); |
Matt Menke | edaf3b8 | 2019-03-14 21:39:44 | [diff] [blame] | 7841 | mock_quic_data2.AddConnect(SYNCHRONOUS, ERR_FAILED); |
| 7842 | mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 7843 | |
| 7844 | int original_max_sockets_per_group = |
| 7845 | ClientSocketPoolManager::max_sockets_per_group( |
| 7846 | HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL); |
| 7847 | ClientSocketPoolManager::set_max_sockets_per_group( |
| 7848 | HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL, 1); |
| 7849 | int original_max_sockets_per_pool = |
| 7850 | ClientSocketPoolManager::max_sockets_per_pool( |
| 7851 | HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL); |
| 7852 | ClientSocketPoolManager::set_max_sockets_per_pool( |
| 7853 | HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL, 1); |
| 7854 | CreateSession(); |
| 7855 | |
| 7856 | request_.url = GURL("https://mail.example.org/"); |
| 7857 | HttpNetworkTransaction trans(kRequestPriority, session_.get()); |
| 7858 | TestCompletionCallback callback; |
| 7859 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7860 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7861 | |
| 7862 | HttpRequestInfo request2; |
| 7863 | request2.url = GURL("https://mail.example.org/some/other/path/"); |
| 7864 | request2.traffic_annotation = |
| 7865 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
| 7866 | |
| 7867 | HttpNetworkTransaction trans2(kRequestPriority2, session_.get()); |
| 7868 | TestCompletionCallback callback2; |
| 7869 | int rv2 = trans2.Start(&request2, callback2.callback(), net_log_.bound()); |
| 7870 | EXPECT_EQ(ERR_IO_PENDING, rv2); |
| 7871 | |
| 7872 | EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback.WaitForResult()); |
| 7873 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7874 | |
| 7875 | EXPECT_EQ(ERR_FAILED, callback2.WaitForResult()); |
| 7876 | |
| 7877 | ClientSocketPoolManager::set_max_sockets_per_pool( |
| 7878 | HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL, |
| 7879 | original_max_sockets_per_pool); |
| 7880 | ClientSocketPoolManager::set_max_sockets_per_group( |
| 7881 | HttpNetworkSession::SocketPoolType::NORMAL_SOCKET_POOL, |
| 7882 | original_max_sockets_per_group); |
| 7883 | } |
| 7884 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7885 | // Test the request-challenge-retry sequence for basic auth, over a QUIC |
| 7886 | // connection when setting up a QUIC proxy tunnel. |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7887 | TEST_P(QuicNetworkTransactionTest, QuicProxyAuth) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7888 | const base::string16 kBaz(base::ASCIIToUTF16("baz")); |
| 7889 | const base::string16 kFoo(base::ASCIIToUTF16("foo")); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7890 | |
| 7891 | std::unique_ptr<QuicTestPacketMaker> client_maker; |
| 7892 | std::unique_ptr<QuicTestPacketMaker> server_maker; |
| 7893 | |
| 7894 | // On the second pass, the body read of the auth challenge is synchronous, so |
| 7895 | // IsConnectedAndIdle returns false. The socket should still be drained and |
| 7896 | // reused. See http://crbug.com/544255. |
| 7897 | for (int i = 0; i < 2; ++i) { |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7898 | client_maker.reset(new QuicTestPacketMaker( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 7899 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 7900 | &clock_, kDefaultServerHostName, quic::Perspective::IS_CLIENT, |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7901 | client_headers_include_h2_stream_dependency_)); |
| 7902 | server_maker.reset(new QuicTestPacketMaker( |
David Schinazi | c828105 | 2019-01-24 06:14:17 | [diff] [blame] | 7903 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 7904 | &clock_, kDefaultServerHostName, quic::Perspective::IS_SERVER, false)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7905 | |
| 7906 | session_params_.enable_quic = true; |
Ryan Hamilton | 4cbcbf1 | 2018-12-15 05:16:14 | [diff] [blame] | 7907 | session_params_.enable_quic_proxies_for_https_urls = true; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7908 | proxy_resolution_service_ = |
| 7909 | ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7910 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7911 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 7912 | MockQuicData mock_quic_data(version_); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7913 | quic::QuicStreamOffset server_data_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7914 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7915 | int packet_num = 1; |
| 7916 | if (VersionUsesQpack(version_.transport_version)) { |
| 7917 | mock_quic_data.AddWrite( |
| 7918 | SYNCHRONOUS, client_maker->MakeInitialSettingsPacket(packet_num++)); |
| 7919 | } |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7920 | |
| 7921 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7922 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7923 | client_maker->MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7924 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 7925 | false, |
Matt Menke | 6e879bd | 2019-03-18 17:26:04 | [diff] [blame] | 7926 | ConvertRequestPriorityToQuicPriority( |
| 7927 | HttpProxyConnectJob::kH2QuicTunnelPriority), |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7928 | client_maker->ConnectRequestHeaders("mail.example.org:443"), 0, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7929 | nullptr)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7930 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7931 | spdy::SpdyHeaderBlock headers = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7932 | server_maker->GetResponseHeaders("407 Proxy Authentication Required"); |
| 7933 | headers["proxy-authenticate"] = "Basic realm=\"MyRealm1\""; |
| 7934 | headers["content-length"] = "10"; |
| 7935 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7936 | ASYNC, server_maker->MakeResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7937 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7938 | false, std::move(headers), nullptr)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7939 | |
| 7940 | if (i == 0) { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7941 | mock_quic_data.AddRead( |
| 7942 | ASYNC, server_maker->MakeDataPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7943 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7944 | false, "0123456789")); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7945 | } else { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7946 | mock_quic_data.AddRead( |
| 7947 | SYNCHRONOUS, server_maker->MakeDataPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7948 | 2, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 7949 | false, false, "0123456789")); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7950 | } |
| 7951 | server_data_offset += 10; |
| 7952 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7953 | mock_quic_data.AddWrite( |
| 7954 | SYNCHRONOUS, client_maker->MakeAckPacket(packet_num++, 2, 1, 1, true)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7955 | |
| 7956 | mock_quic_data.AddWrite( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7957 | SYNCHRONOUS, |
| 7958 | client_maker->MakeRstPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7959 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | b5d4c5a | 2019-06-21 22:08:41 | [diff] [blame] | 7960 | quic::QUIC_STREAM_CANCELLED, |
Frank Kastenholz | 684ea41 | 2019-02-13 18:48:18 | [diff] [blame] | 7961 | /*include_stop_sending_if_v99=*/true)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7962 | |
| 7963 | headers = client_maker->ConnectRequestHeaders("mail.example.org:443"); |
| 7964 | headers["proxy-authorization"] = "Basic Zm9vOmJheg=="; |
| 7965 | mock_quic_data.AddWrite( |
Matt Menke | 6e879bd | 2019-03-18 17:26:04 | [diff] [blame] | 7966 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7967 | client_maker->MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7968 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 7969 | false, |
Matt Menke | 6e879bd | 2019-03-18 17:26:04 | [diff] [blame] | 7970 | ConvertRequestPriorityToQuicPriority( |
| 7971 | HttpProxyConnectJob::kH2QuicTunnelPriority), |
| 7972 | std::move(headers), GetNthClientInitiatedBidirectionalStreamId(0), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7973 | nullptr)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7974 | |
| 7975 | // Response to wrong password |
| 7976 | headers = |
| 7977 | server_maker->GetResponseHeaders("407 Proxy Authentication Required"); |
| 7978 | headers["proxy-authenticate"] = "Basic realm=\"MyRealm1\""; |
| 7979 | headers["content-length"] = "10"; |
| 7980 | mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7981 | ASYNC, server_maker->MakeResponseHeadersPacket( |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7982 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 7983 | false, std::move(headers), nullptr)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7984 | mock_quic_data.AddRead(SYNCHRONOUS, |
| 7985 | ERR_IO_PENDING); // No more data to read |
| 7986 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7987 | mock_quic_data.AddWrite( |
| 7988 | SYNCHRONOUS, |
| 7989 | client_maker->MakeAckAndRstPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 7990 | packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(1), |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 7991 | quic::QUIC_STREAM_CANCELLED, 3, 3, 1, true)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7992 | |
| 7993 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7994 | mock_quic_data.GetSequencedSocketData()->set_busy_before_sync_reads(true); |
| 7995 | |
| 7996 | CreateSession(); |
| 7997 | |
| 7998 | request_.url = GURL("https://mail.example.org/"); |
| 7999 | // Ensure that proxy authentication is attempted even |
| 8000 | // when the no authentication data flag is set. |
| 8001 | request_.load_flags = LOAD_DO_NOT_SEND_AUTH_DATA; |
| 8002 | { |
| 8003 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 8004 | HeadersHandler headers_handler; |
| 8005 | trans.SetBeforeHeadersSentCallback( |
| 8006 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 8007 | base::Unretained(&headers_handler))); |
| 8008 | RunTransaction(&trans); |
| 8009 | |
| 8010 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
| 8011 | ASSERT_TRUE(response != nullptr); |
| 8012 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 8013 | EXPECT_EQ("HTTP/1.1 407 Proxy Authentication Required", |
| 8014 | response->headers->GetStatusLine()); |
| 8015 | EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 8016 | EXPECT_EQ(407, response->headers->response_code()); |
| 8017 | EXPECT_EQ(10, response->headers->GetContentLength()); |
| 8018 | EXPECT_EQ(HttpVersion(1, 1), response->headers->GetHttpVersion()); |
Emily Stark | f2c9bbd | 2019-04-09 17:08:58 | [diff] [blame] | 8019 | base::Optional<AuthChallengeInfo> auth_challenge = |
| 8020 | response->auth_challenge; |
| 8021 | ASSERT_TRUE(auth_challenge.has_value()); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8022 | EXPECT_TRUE(auth_challenge->is_proxy); |
| 8023 | EXPECT_EQ("https://proxy.example.org:70", |
| 8024 | auth_challenge->challenger.Serialize()); |
| 8025 | EXPECT_EQ("MyRealm1", auth_challenge->realm); |
| 8026 | EXPECT_EQ("basic", auth_challenge->scheme); |
| 8027 | |
| 8028 | TestCompletionCallback callback; |
| 8029 | int rv = trans.RestartWithAuth(AuthCredentials(kFoo, kBaz), |
| 8030 | callback.callback()); |
| 8031 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 8032 | EXPECT_EQ(OK, callback.WaitForResult()); |
| 8033 | |
| 8034 | response = trans.GetResponseInfo(); |
| 8035 | ASSERT_TRUE(response != nullptr); |
| 8036 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 8037 | EXPECT_EQ("HTTP/1.1 407 Proxy Authentication Required", |
| 8038 | response->headers->GetStatusLine()); |
| 8039 | EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 8040 | EXPECT_EQ(407, response->headers->response_code()); |
| 8041 | EXPECT_EQ(10, response->headers->GetContentLength()); |
| 8042 | EXPECT_EQ(HttpVersion(1, 1), response->headers->GetHttpVersion()); |
Emily Stark | f2c9bbd | 2019-04-09 17:08:58 | [diff] [blame] | 8043 | auth_challenge = response->auth_challenge; |
| 8044 | ASSERT_TRUE(auth_challenge.has_value()); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8045 | EXPECT_TRUE(auth_challenge->is_proxy); |
| 8046 | EXPECT_EQ("https://proxy.example.org:70", |
| 8047 | auth_challenge->challenger.Serialize()); |
| 8048 | EXPECT_EQ("MyRealm1", auth_challenge->realm); |
| 8049 | EXPECT_EQ("basic", auth_challenge->scheme); |
| 8050 | } |
| 8051 | // HttpNetworkTransaction is torn down now that it's out of scope, causing |
| 8052 | // the QUIC stream to be cleaned up (since the proxy socket cannot be |
| 8053 | // reused because it's not connected). |
| 8054 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 8055 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 8056 | } |
| 8057 | } |
| 8058 | |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8059 | TEST_P(QuicNetworkTransactionTest, QuicServerPushUpdatesPriority) { |
| 8060 | // Only run this test if HTTP/2 stream dependency info is sent by client (sent |
| 8061 | // in HEADERS frames for requests and PRIORITY frames). |
Nick Harper | 23290b8 | 2019-05-02 00:02:56 | [diff] [blame] | 8062 | if (version_.transport_version < quic::QUIC_VERSION_43 || |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8063 | !client_headers_include_h2_stream_dependency_) { |
| 8064 | return; |
| 8065 | } |
| 8066 | |
Ryan Hamilton | e940bd1 | 2019-06-30 02:46:45 | [diff] [blame] | 8067 | if (quic::VersionUsesQpack(version_.transport_version)) { |
| 8068 | // TODO(rch): both stream_dependencies and priority frames need to be |
| 8069 | // supported in IETF QUIC. |
| 8070 | return; |
| 8071 | } |
| 8072 | |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 8073 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8074 | HostPortPair::FromString("mail.example.org:443")); |
| 8075 | |
Fan Yang | 32c5a11 | 2018-12-10 20:06:33 | [diff] [blame] | 8076 | const quic::QuicStreamId client_stream_0 = |
| 8077 | GetNthClientInitiatedBidirectionalStreamId(0); |
| 8078 | const quic::QuicStreamId client_stream_1 = |
| 8079 | GetNthClientInitiatedBidirectionalStreamId(1); |
| 8080 | const quic::QuicStreamId client_stream_2 = |
| 8081 | GetNthClientInitiatedBidirectionalStreamId(2); |
| 8082 | const quic::QuicStreamId push_stream_0 = |
| 8083 | GetNthServerInitiatedUnidirectionalStreamId(0); |
| 8084 | const quic::QuicStreamId push_stream_1 = |
| 8085 | GetNthServerInitiatedUnidirectionalStreamId(1); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8086 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8087 | MockQuicData mock_quic_data(version_); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8088 | int packet_num = 1; |
| 8089 | if (VersionUsesQpack(version_.transport_version)) { |
| 8090 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8091 | ConstructInitialSettingsPacket(packet_num++)); |
| 8092 | } |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8093 | |
| 8094 | // Client sends "GET" requests for "/0.png", "/1.png", "/2.png". |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8095 | mock_quic_data.AddWrite( |
| 8096 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 8097 | packet_num++, client_stream_0, true, true, HIGHEST, |
| 8098 | GetRequestHeaders("GET", "https", "/0.jpg"), 0)); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8099 | mock_quic_data.AddWrite( |
| 8100 | SYNCHRONOUS, |
| 8101 | ConstructClientRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8102 | packet_num++, client_stream_1, true, true, MEDIUM, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8103 | GetRequestHeaders("GET", "https", "/1.jpg"), client_stream_0)); |
| 8104 | mock_quic_data.AddWrite( |
| 8105 | SYNCHRONOUS, |
| 8106 | ConstructClientRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8107 | packet_num++, client_stream_2, true, true, MEDIUM, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8108 | GetRequestHeaders("GET", "https", "/2.jpg"), client_stream_1)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8109 | |
| 8110 | // Server replies "OK" for the three requests. |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8111 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 8112 | 1, client_stream_0, false, false, |
| 8113 | GetResponseHeaders("200 OK"))); |
| 8114 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 8115 | 2, client_stream_1, false, false, |
| 8116 | GetResponseHeaders("200 OK"))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8117 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8118 | ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8119 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 8120 | 3, client_stream_2, false, false, |
| 8121 | GetResponseHeaders("200 OK"))); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8122 | |
| 8123 | // Server sends two push promises associated with |client_stream_0|; client |
| 8124 | // responds with a PRIORITY frame after each to notify server of HTTP/2 stream |
| 8125 | // dependency info for each push promise stream. |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8126 | mock_quic_data.AddRead( |
| 8127 | ASYNC, |
| 8128 | ConstructServerPushPromisePacket( |
| 8129 | 4, client_stream_0, push_stream_0, false, |
| 8130 | GetRequestHeaders("GET", "https", "/pushed_0.jpg"), &server_maker_)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8131 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8132 | SYNCHRONOUS, |
| 8133 | ConstructClientAckAndPriorityFramesPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8134 | packet_num++, false, 4, 3, 1, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8135 | {{push_stream_0, client_stream_2, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8136 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY)}})); |
| 8137 | mock_quic_data.AddRead( |
| 8138 | ASYNC, |
| 8139 | ConstructServerPushPromisePacket( |
| 8140 | 5, client_stream_0, push_stream_1, false, |
| 8141 | GetRequestHeaders("GET", "https", "/pushed_1.jpg"), &server_maker_)); |
| 8142 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientPriorityPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8143 | packet_num++, false, push_stream_1, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8144 | push_stream_0, DEFAULT_PRIORITY)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8145 | |
| 8146 | // Server sends the response headers for the two push promises. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8147 | mock_quic_data.AddRead( |
| 8148 | ASYNC, ConstructServerResponseHeadersPacket( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8149 | 6, push_stream_0, false, false, GetResponseHeaders("200 OK"))); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8150 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8151 | ConstructClientAckPacket(packet_num++, 6, 5, 1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8152 | mock_quic_data.AddRead( |
| 8153 | ASYNC, ConstructServerResponseHeadersPacket( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8154 | 7, push_stream_1, false, false, GetResponseHeaders("200 OK"))); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8155 | |
| 8156 | // Request for "pushed_0.jpg" matches |push_stream_0|. |push_stream_0|'s |
| 8157 | // priority updates to match the request's priority. Client sends PRIORITY |
| 8158 | // frames to inform server of new HTTP/2 stream dependencies. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8159 | mock_quic_data.AddWrite( |
| 8160 | SYNCHRONOUS, |
| 8161 | ConstructClientAckAndPriorityFramesPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8162 | packet_num++, false, 7, 7, 1, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8163 | {{push_stream_1, client_stream_2, |
| 8164 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY)}, |
| 8165 | {push_stream_0, client_stream_0, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8166 | ConvertRequestPriorityToQuicPriority(HIGHEST)}})); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8167 | |
| 8168 | // Server sends data for the three requests and the two push promises. |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 8169 | std::string header = ConstructDataHeader(8); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8170 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8171 | ASYNC, ConstructServerDataPacket(8, client_stream_0, false, true, |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 8172 | header + "hello 0!")); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8173 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8174 | SYNCHRONOUS, ConstructServerDataPacket(9, client_stream_1, false, true, |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 8175 | header + "hello 1!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8176 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8177 | ConstructClientAckPacket(packet_num++, 9, 8, 1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8178 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8179 | ASYNC, ConstructServerDataPacket(10, client_stream_2, false, true, |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 8180 | header + "hello 2!")); |
Victor Vasiliev | 076657c | 2019-03-12 02:46:43 | [diff] [blame] | 8181 | std::string header2 = ConstructDataHeader(12); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8182 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8183 | SYNCHRONOUS, ConstructServerDataPacket(11, push_stream_0, false, true, |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 8184 | header2 + "and hello 0!")); |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8185 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8186 | ConstructClientAckPacket(packet_num++, 11, 10, 1)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8187 | mock_quic_data.AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8188 | ASYNC, ConstructServerDataPacket(12, push_stream_1, false, true, |
Renjie | f49758b | 2019-01-11 23:32:41 | [diff] [blame] | 8189 | header2 + "and hello 1!")); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8190 | |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8191 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 8192 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 8193 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 8194 | |
| 8195 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 8196 | // the alternate-protocol job will "win". |
| 8197 | AddHangingNonAlternateProtocolSocketData(); |
| 8198 | |
| 8199 | CreateSession(); |
| 8200 | |
| 8201 | request_.url = GURL("https://mail.example.org/0.jpg"); |
| 8202 | HttpNetworkTransaction trans_0(HIGHEST, session_.get()); |
| 8203 | TestCompletionCallback callback_0; |
| 8204 | EXPECT_EQ(ERR_IO_PENDING, |
| 8205 | trans_0.Start(&request_, callback_0.callback(), net_log_.bound())); |
| 8206 | base::RunLoop().RunUntilIdle(); |
| 8207 | |
| 8208 | request_.url = GURL("https://mail.example.org/1.jpg"); |
| 8209 | HttpNetworkTransaction trans_1(MEDIUM, session_.get()); |
| 8210 | TestCompletionCallback callback_1; |
| 8211 | EXPECT_EQ(ERR_IO_PENDING, |
| 8212 | trans_1.Start(&request_, callback_1.callback(), net_log_.bound())); |
| 8213 | base::RunLoop().RunUntilIdle(); |
| 8214 | |
| 8215 | request_.url = GURL("https://mail.example.org/2.jpg"); |
| 8216 | HttpNetworkTransaction trans_2(MEDIUM, session_.get()); |
| 8217 | TestCompletionCallback callback_2; |
| 8218 | EXPECT_EQ(ERR_IO_PENDING, |
| 8219 | trans_2.Start(&request_, callback_2.callback(), net_log_.bound())); |
| 8220 | base::RunLoop().RunUntilIdle(); |
| 8221 | |
| 8222 | // Client makes request that matches resource pushed in |pushed_stream_0|. |
| 8223 | request_.url = GURL("https://mail.example.org/pushed_0.jpg"); |
| 8224 | HttpNetworkTransaction trans_3(HIGHEST, session_.get()); |
| 8225 | TestCompletionCallback callback_3; |
| 8226 | EXPECT_EQ(ERR_IO_PENDING, |
| 8227 | trans_3.Start(&request_, callback_3.callback(), net_log_.bound())); |
| 8228 | base::RunLoop().RunUntilIdle(); |
| 8229 | |
| 8230 | EXPECT_TRUE(callback_0.have_result()); |
| 8231 | EXPECT_EQ(OK, callback_0.WaitForResult()); |
| 8232 | EXPECT_TRUE(callback_1.have_result()); |
| 8233 | EXPECT_EQ(OK, callback_1.WaitForResult()); |
| 8234 | EXPECT_TRUE(callback_2.have_result()); |
| 8235 | EXPECT_EQ(OK, callback_2.WaitForResult()); |
| 8236 | |
| 8237 | CheckResponseData(&trans_0, "hello 0!"); // Closes stream 5 |
| 8238 | CheckResponseData(&trans_1, "hello 1!"); // Closes stream 7 |
| 8239 | CheckResponseData(&trans_2, "hello 2!"); // Closes strema 9 |
| 8240 | CheckResponseData(&trans_3, "and hello 0!"); // Closes stream 2, sends RST |
| 8241 | |
| 8242 | mock_quic_data.Resume(); |
| 8243 | base::RunLoop().RunUntilIdle(); |
| 8244 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 8245 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 8246 | } |
| 8247 | |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8248 | // Test that NetworkIsolationKey is respected by QUIC connections, when |
| 8249 | // kPartitionConnectionsByNetworkIsolationKey is enabled. |
| 8250 | TEST_P(QuicNetworkTransactionTest, NetworkIsolation) { |
Shivani Sharma | 8ae506c | 2019-07-21 21:08:27 | [diff] [blame] | 8251 | const auto kOrigin1 = url::Origin::Create(GURL("http://origin1/")); |
| 8252 | const auto kOrigin2 = url::Origin::Create(GURL("http://origin2/")); |
| 8253 | NetworkIsolationKey network_isolation_key1(kOrigin1, kOrigin1); |
| 8254 | NetworkIsolationKey network_isolation_key2(kOrigin2, kOrigin2); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8255 | |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 8256 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8257 | HostPortPair::FromString("mail.example.org:443")); |
| 8258 | |
| 8259 | // Whether to use an H2 proxy. When false, uses HTTPS H2 requests without a |
| 8260 | // proxy, when true, uses HTTP requests over an H2 proxy. It's unnecessary to |
| 8261 | // test tunneled HTTPS over an H2 proxy, since that path sets up H2 sessions |
| 8262 | // the same way as the HTTP over H2 proxy case. |
| 8263 | for (bool use_proxy : {false, true}) { |
| 8264 | SCOPED_TRACE(use_proxy); |
| 8265 | |
| 8266 | if (use_proxy) { |
| 8267 | proxy_resolution_service_ = |
| 8268 | ProxyResolutionService::CreateFixedFromPacResult( |
| 8269 | "QUIC mail.example.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
| 8270 | } else { |
| 8271 | proxy_resolution_service_ = ProxyResolutionService::CreateDirect(); |
| 8272 | } |
| 8273 | |
| 8274 | GURL url1; |
| 8275 | GURL url2; |
| 8276 | GURL url3; |
| 8277 | if (use_proxy) { |
| 8278 | url1 = GURL("http://mail.example.org/1"); |
| 8279 | url2 = GURL("http://mail.example.org/2"); |
| 8280 | url3 = GURL("http://mail.example.org/3"); |
| 8281 | } else { |
| 8282 | url1 = GURL("https://mail.example.org/1"); |
| 8283 | url2 = GURL("https://mail.example.org/2"); |
| 8284 | url3 = GURL("https://mail.example.org/3"); |
| 8285 | } |
| 8286 | |
| 8287 | for (bool partition_connections : {false, true}) { |
| 8288 | SCOPED_TRACE(partition_connections); |
| 8289 | |
| 8290 | base::test::ScopedFeatureList feature_list; |
| 8291 | if (partition_connections) { |
| 8292 | feature_list.InitAndEnableFeature( |
| 8293 | features::kPartitionConnectionsByNetworkIsolationKey); |
| 8294 | } else { |
| 8295 | feature_list.InitAndDisableFeature( |
| 8296 | features::kPartitionConnectionsByNetworkIsolationKey); |
| 8297 | } |
| 8298 | |
| 8299 | // Reads and writes for the unpartitioned case, where only one socket is |
| 8300 | // used. |
| 8301 | |
Nick Harper | 72ade19 | 2019-07-17 03:30:42 | [diff] [blame] | 8302 | session_params_.quic_params.origins_to_force_quic_on.insert( |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8303 | HostPortPair::FromString("mail.example.org:443")); |
| 8304 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8305 | MockQuicData unpartitioned_mock_quic_data(version_); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8306 | QuicTestPacketMaker client_maker1( |
| 8307 | version_, |
| 8308 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8309 | &clock_, kDefaultServerHostName, quic::Perspective::IS_CLIENT, |
| 8310 | client_headers_include_h2_stream_dependency_); |
| 8311 | QuicTestPacketMaker server_maker1( |
| 8312 | version_, |
| 8313 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8314 | &clock_, kDefaultServerHostName, quic::Perspective::IS_SERVER, false); |
| 8315 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8316 | int packet_num = 1; |
| 8317 | if (VersionUsesQpack(version_.transport_version)) { |
| 8318 | unpartitioned_mock_quic_data.AddWrite( |
| 8319 | SYNCHRONOUS, client_maker1.MakeInitialSettingsPacket(packet_num++)); |
| 8320 | } |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8321 | |
| 8322 | unpartitioned_mock_quic_data.AddWrite( |
| 8323 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8324 | client_maker1.MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8325 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 8326 | true, ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8327 | GetRequestHeaders("GET", url1.scheme(), "/1"), 0, nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8328 | unpartitioned_mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8329 | ASYNC, server_maker1.MakeResponseHeadersPacket( |
| 8330 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, |
| 8331 | false, GetResponseHeaders("200 OK"), nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8332 | unpartitioned_mock_quic_data.AddRead( |
| 8333 | ASYNC, server_maker1.MakeDataPacket( |
| 8334 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8335 | true, ConstructDataHeader(1) + "1")); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8336 | unpartitioned_mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8337 | SYNCHRONOUS, ConstructClientAckPacket(packet_num++, 2, 1, 1)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8338 | |
| 8339 | unpartitioned_mock_quic_data.AddWrite( |
| 8340 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8341 | client_maker1.MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8342 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(1), |
| 8343 | false, true, |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8344 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8345 | GetRequestHeaders("GET", url2.scheme(), "/2"), 0, nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8346 | unpartitioned_mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8347 | ASYNC, server_maker1.MakeResponseHeadersPacket( |
| 8348 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 8349 | false, GetResponseHeaders("200 OK"), nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8350 | unpartitioned_mock_quic_data.AddRead( |
| 8351 | ASYNC, server_maker1.MakeDataPacket( |
| 8352 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8353 | true, ConstructDataHeader(1) + "2")); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8354 | unpartitioned_mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8355 | SYNCHRONOUS, |
| 8356 | ConstructClientAckAndConnectionClosePacket(packet_num++, 4, 3, 1)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8357 | |
| 8358 | unpartitioned_mock_quic_data.AddWrite( |
| 8359 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8360 | client_maker1.MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8361 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(2), |
| 8362 | false, true, |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8363 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8364 | GetRequestHeaders("GET", url3.scheme(), "/3"), 0, nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8365 | unpartitioned_mock_quic_data.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8366 | ASYNC, server_maker1.MakeResponseHeadersPacket( |
| 8367 | 5, GetNthClientInitiatedBidirectionalStreamId(2), false, |
| 8368 | false, GetResponseHeaders("200 OK"), nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8369 | unpartitioned_mock_quic_data.AddRead( |
| 8370 | ASYNC, server_maker1.MakeDataPacket( |
| 8371 | 6, GetNthClientInitiatedBidirectionalStreamId(2), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8372 | true, ConstructDataHeader(1) + "3")); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8373 | unpartitioned_mock_quic_data.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8374 | SYNCHRONOUS, |
| 8375 | ConstructClientAckAndConnectionClosePacket(packet_num++, 6, 5, 1)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8376 | |
| 8377 | unpartitioned_mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 8378 | |
| 8379 | // Reads and writes for the partitioned case, where two sockets are used. |
| 8380 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8381 | MockQuicData partitioned_mock_quic_data1(version_); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8382 | QuicTestPacketMaker client_maker2( |
| 8383 | version_, |
| 8384 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8385 | &clock_, kDefaultServerHostName, quic::Perspective::IS_CLIENT, |
| 8386 | client_headers_include_h2_stream_dependency_); |
| 8387 | QuicTestPacketMaker server_maker2( |
| 8388 | version_, |
| 8389 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8390 | &clock_, kDefaultServerHostName, quic::Perspective::IS_SERVER, false); |
| 8391 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8392 | int packet_num2 = 1; |
| 8393 | if (VersionUsesQpack(version_.transport_version)) { |
| 8394 | partitioned_mock_quic_data1.AddWrite( |
| 8395 | SYNCHRONOUS, |
| 8396 | client_maker2.MakeInitialSettingsPacket(packet_num2++)); |
| 8397 | } |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8398 | |
| 8399 | partitioned_mock_quic_data1.AddWrite( |
| 8400 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8401 | client_maker2.MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8402 | packet_num2++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 8403 | true, true, |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8404 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8405 | GetRequestHeaders("GET", url1.scheme(), "/1"), 0, nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8406 | partitioned_mock_quic_data1.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8407 | ASYNC, server_maker2.MakeResponseHeadersPacket( |
| 8408 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, |
| 8409 | false, GetResponseHeaders("200 OK"), nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8410 | partitioned_mock_quic_data1.AddRead( |
| 8411 | ASYNC, server_maker2.MakeDataPacket( |
| 8412 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8413 | true, ConstructDataHeader(1) + "1")); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8414 | partitioned_mock_quic_data1.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8415 | SYNCHRONOUS, |
| 8416 | client_maker2.MakeAckPacket(packet_num2++, 2, 1, 1, true)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8417 | |
| 8418 | partitioned_mock_quic_data1.AddWrite( |
| 8419 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8420 | client_maker2.MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8421 | packet_num2++, GetNthClientInitiatedBidirectionalStreamId(1), |
| 8422 | false, true, |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8423 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8424 | GetRequestHeaders("GET", url3.scheme(), "/3"), 0, nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8425 | partitioned_mock_quic_data1.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8426 | ASYNC, server_maker2.MakeResponseHeadersPacket( |
| 8427 | 3, GetNthClientInitiatedBidirectionalStreamId(1), false, |
| 8428 | false, GetResponseHeaders("200 OK"), nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8429 | partitioned_mock_quic_data1.AddRead( |
| 8430 | ASYNC, server_maker2.MakeDataPacket( |
| 8431 | 4, GetNthClientInitiatedBidirectionalStreamId(1), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8432 | true, ConstructDataHeader(1) + "3")); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8433 | partitioned_mock_quic_data1.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8434 | SYNCHRONOUS, |
| 8435 | client_maker2.MakeAckPacket(packet_num2++, 4, 3, 1, true)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8436 | |
| 8437 | partitioned_mock_quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 8438 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8439 | MockQuicData partitioned_mock_quic_data2(version_); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8440 | QuicTestPacketMaker client_maker3( |
| 8441 | version_, |
| 8442 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8443 | &clock_, kDefaultServerHostName, quic::Perspective::IS_CLIENT, |
| 8444 | client_headers_include_h2_stream_dependency_); |
| 8445 | QuicTestPacketMaker server_maker3( |
| 8446 | version_, |
| 8447 | quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8448 | &clock_, kDefaultServerHostName, quic::Perspective::IS_SERVER, false); |
| 8449 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8450 | int packet_num3 = 1; |
| 8451 | if (VersionUsesQpack(version_.transport_version)) { |
| 8452 | partitioned_mock_quic_data2.AddWrite( |
| 8453 | SYNCHRONOUS, |
| 8454 | client_maker3.MakeInitialSettingsPacket(packet_num3++)); |
| 8455 | } |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8456 | |
| 8457 | partitioned_mock_quic_data2.AddWrite( |
| 8458 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8459 | client_maker3.MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8460 | packet_num3++, GetNthClientInitiatedBidirectionalStreamId(0), |
| 8461 | true, true, |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8462 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8463 | GetRequestHeaders("GET", url2.scheme(), "/2"), 0, nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8464 | partitioned_mock_quic_data2.AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8465 | ASYNC, server_maker3.MakeResponseHeadersPacket( |
| 8466 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, |
| 8467 | false, GetResponseHeaders("200 OK"), nullptr)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8468 | partitioned_mock_quic_data2.AddRead( |
| 8469 | ASYNC, server_maker3.MakeDataPacket( |
| 8470 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8471 | true, ConstructDataHeader(1) + "2")); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8472 | partitioned_mock_quic_data2.AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8473 | SYNCHRONOUS, |
| 8474 | client_maker3.MakeAckPacket(packet_num3++, 2, 1, 1, true)); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8475 | |
| 8476 | partitioned_mock_quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 8477 | |
| 8478 | if (partition_connections) { |
| 8479 | partitioned_mock_quic_data1.AddSocketDataToFactory(&socket_factory_); |
| 8480 | partitioned_mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 8481 | } else { |
| 8482 | unpartitioned_mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 8483 | } |
| 8484 | |
| 8485 | CreateSession(); |
| 8486 | |
| 8487 | TestCompletionCallback callback; |
| 8488 | HttpRequestInfo request1; |
| 8489 | request1.method = "GET"; |
| 8490 | request1.url = GURL(url1); |
| 8491 | request1.traffic_annotation = |
| 8492 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
| 8493 | request1.network_isolation_key = network_isolation_key1; |
| 8494 | HttpNetworkTransaction trans1(LOWEST, session_.get()); |
| 8495 | int rv = trans1.Start(&request1, callback.callback(), NetLogWithSource()); |
| 8496 | EXPECT_THAT(callback.GetResult(rv), IsOk()); |
| 8497 | std::string response_data1; |
| 8498 | EXPECT_THAT(ReadTransaction(&trans1, &response_data1), IsOk()); |
| 8499 | EXPECT_EQ("1", response_data1); |
| 8500 | |
| 8501 | HttpRequestInfo request2; |
| 8502 | request2.method = "GET"; |
| 8503 | request2.url = GURL(url2); |
| 8504 | request2.traffic_annotation = |
| 8505 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
| 8506 | request2.network_isolation_key = network_isolation_key2; |
| 8507 | HttpNetworkTransaction trans2(LOWEST, session_.get()); |
| 8508 | rv = trans2.Start(&request2, callback.callback(), NetLogWithSource()); |
| 8509 | EXPECT_THAT(callback.GetResult(rv), IsOk()); |
| 8510 | std::string response_data2; |
| 8511 | EXPECT_THAT(ReadTransaction(&trans2, &response_data2), IsOk()); |
| 8512 | EXPECT_EQ("2", response_data2); |
| 8513 | |
| 8514 | HttpRequestInfo request3; |
| 8515 | request3.method = "GET"; |
| 8516 | request3.url = GURL(url3); |
| 8517 | request3.traffic_annotation = |
| 8518 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
| 8519 | request3.network_isolation_key = network_isolation_key1; |
| 8520 | HttpNetworkTransaction trans3(LOWEST, session_.get()); |
| 8521 | rv = trans3.Start(&request3, callback.callback(), NetLogWithSource()); |
| 8522 | EXPECT_THAT(callback.GetResult(rv), IsOk()); |
| 8523 | std::string response_data3; |
| 8524 | EXPECT_THAT(ReadTransaction(&trans3, &response_data3), IsOk()); |
| 8525 | EXPECT_EQ("3", response_data3); |
| 8526 | |
| 8527 | if (partition_connections) { |
| 8528 | EXPECT_TRUE(partitioned_mock_quic_data1.AllReadDataConsumed()); |
| 8529 | EXPECT_TRUE(partitioned_mock_quic_data1.AllWriteDataConsumed()); |
| 8530 | EXPECT_TRUE(partitioned_mock_quic_data2.AllReadDataConsumed()); |
| 8531 | EXPECT_TRUE(partitioned_mock_quic_data2.AllWriteDataConsumed()); |
| 8532 | } else { |
| 8533 | EXPECT_TRUE(unpartitioned_mock_quic_data.AllReadDataConsumed()); |
| 8534 | EXPECT_TRUE(unpartitioned_mock_quic_data.AllWriteDataConsumed()); |
| 8535 | } |
| 8536 | } |
| 8537 | } |
| 8538 | } |
| 8539 | |
| 8540 | // Test that two requests to the same origin over QUIC tunnels use different |
| 8541 | // QUIC sessions if their NetworkIsolationKeys don't match, and |
| 8542 | // kPartitionConnectionsByNetworkIsolationKey is enabled. |
| 8543 | TEST_P(QuicNetworkTransactionTest, NetworkIsolationTunnel) { |
| 8544 | base::test::ScopedFeatureList feature_list; |
| 8545 | feature_list.InitAndEnableFeature( |
| 8546 | features::kPartitionConnectionsByNetworkIsolationKey); |
| 8547 | |
| 8548 | session_params_.enable_quic = true; |
| 8549 | session_params_.enable_quic_proxies_for_https_urls = true; |
| 8550 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| 8551 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
| 8552 | |
| 8553 | const char kGetRequest[] = |
| 8554 | "GET / HTTP/1.1\r\n" |
| 8555 | "Host: mail.example.org\r\n" |
| 8556 | "Connection: keep-alive\r\n\r\n"; |
| 8557 | const char kGetResponse[] = |
| 8558 | "HTTP/1.1 200 OK\r\n" |
| 8559 | "Content-Length: 10\r\n\r\n"; |
| 8560 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8561 | std::unique_ptr<MockQuicData> mock_quic_data[2] = { |
| 8562 | std::make_unique<MockQuicData>(version_), |
| 8563 | std::make_unique<MockQuicData>(version_)}; |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8564 | |
| 8565 | for (int index : {0, 1}) { |
| 8566 | QuicTestPacketMaker client_maker( |
| 8567 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8568 | &clock_, kDefaultServerHostName, quic::Perspective::IS_CLIENT, |
| 8569 | client_headers_include_h2_stream_dependency_); |
| 8570 | QuicTestPacketMaker server_maker( |
| 8571 | version_, quic::QuicUtils::CreateRandomConnectionId(&random_generator_), |
| 8572 | &clock_, kDefaultServerHostName, quic::Perspective::IS_SERVER, false); |
| 8573 | |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8574 | int packet_num = 1; |
| 8575 | if (VersionUsesQpack(version_.transport_version)) { |
| 8576 | mock_quic_data[index]->AddWrite( |
| 8577 | SYNCHRONOUS, client_maker.MakeInitialSettingsPacket(packet_num++)); |
| 8578 | } |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8579 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8580 | mock_quic_data[index]->AddWrite( |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8581 | SYNCHRONOUS, |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8582 | client_maker.MakeRequestHeadersPacket( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8583 | packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), true, |
| 8584 | false, |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8585 | ConvertRequestPriorityToQuicPriority( |
| 8586 | HttpProxyConnectJob::kH2QuicTunnelPriority), |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8587 | ConnectRequestHeaders("mail.example.org:443"), 0, nullptr)); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8588 | mock_quic_data[index]->AddRead( |
Ryan Hamilton | 0d65a8c | 2019-06-07 00:46:02 | [diff] [blame] | 8589 | ASYNC, server_maker.MakeResponseHeadersPacket( |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8590 | 1, GetNthClientInitiatedBidirectionalStreamId(0), false, |
| 8591 | false, GetResponseHeaders("200 OK"), nullptr)); |
| 8592 | |
| 8593 | std::string header = ConstructDataHeader(strlen(kGetRequest)); |
| 8594 | if (version_.transport_version != quic::QUIC_VERSION_99) { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8595 | mock_quic_data[index]->AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8596 | SYNCHRONOUS, client_maker.MakeAckAndDataPacket( |
| 8597 | packet_num++, false, |
| 8598 | GetNthClientInitiatedBidirectionalStreamId(0), 1, 1, |
| 8599 | 1, false, quic::QuicStringPiece(kGetRequest))); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8600 | } else { |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8601 | mock_quic_data[index]->AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8602 | SYNCHRONOUS, client_maker.MakeAckAndMultipleDataFramesPacket( |
| 8603 | packet_num++, false, |
| 8604 | GetNthClientInitiatedBidirectionalStreamId(0), 1, 1, |
| 8605 | 1, false, {header, std::string(kGetRequest)})); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8606 | } |
| 8607 | |
| 8608 | std::string header2 = ConstructDataHeader(strlen(kGetResponse)); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8609 | mock_quic_data[index]->AddRead( |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8610 | ASYNC, server_maker.MakeDataPacket( |
| 8611 | 2, GetNthClientInitiatedBidirectionalStreamId(0), false, |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8612 | false, header2 + std::string(kGetResponse))); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8613 | mock_quic_data[index]->AddRead( |
Ryan Hamilton | 7505eb9 | 2019-06-08 00:22:17 | [diff] [blame] | 8614 | SYNCHRONOUS, |
| 8615 | server_maker.MakeDataPacket( |
| 8616 | 3, GetNthClientInitiatedBidirectionalStreamId(0), false, false, |
| 8617 | ConstructDataHeader(10) + std::string("0123456789"))); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8618 | mock_quic_data[index]->AddWrite( |
Renjie Tang | aadb84b | 2019-08-31 01:00:23 | [diff] [blame] | 8619 | SYNCHRONOUS, client_maker.MakeAckPacket(packet_num++, 3, 2, 1, true)); |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8620 | mock_quic_data[index]->AddRead(SYNCHRONOUS, |
| 8621 | ERR_IO_PENDING); // No more data to read |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8622 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8623 | mock_quic_data[index]->AddSocketDataToFactory(&socket_factory_); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8624 | } |
| 8625 | |
| 8626 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 8627 | SSLSocketDataProvider ssl_data2(ASYNC, OK); |
| 8628 | socket_factory_.AddSSLSocketDataProvider(&ssl_data2); |
| 8629 | |
| 8630 | CreateSession(); |
| 8631 | |
| 8632 | request_.url = GURL("https://mail.example.org/"); |
| 8633 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
| 8634 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 8635 | RunTransaction(&trans); |
| 8636 | CheckResponseData(&trans, "0123456789"); |
| 8637 | |
| 8638 | HttpRequestInfo request2; |
Shivani Sharma | 8ae506c | 2019-07-21 21:08:27 | [diff] [blame] | 8639 | const auto kOrigin1 = url::Origin::Create(GURL("http://origin1/")); |
| 8640 | request_.network_isolation_key = NetworkIsolationKey(kOrigin1, kOrigin1); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8641 | HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session_.get()); |
| 8642 | RunTransaction(&trans2); |
| 8643 | CheckResponseData(&trans2, "0123456789"); |
| 8644 | |
Ryan Hamilton | abad59e | 2019-06-06 04:02:59 | [diff] [blame] | 8645 | EXPECT_TRUE(mock_quic_data[0]->AllReadDataConsumed()); |
| 8646 | EXPECT_TRUE(mock_quic_data[0]->AllWriteDataConsumed()); |
| 8647 | EXPECT_TRUE(mock_quic_data[1]->AllReadDataConsumed()); |
| 8648 | EXPECT_TRUE(mock_quic_data[1]->AllWriteDataConsumed()); |
Matt Menke | 26e4154 | 2019-06-05 01:09:51 | [diff] [blame] | 8649 | } |
| 8650 | |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 8651 | } // namespace test |
| 8652 | } // namespace net |