[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 | |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 11 | #include "base/compiler_specific.h" |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 12 | #include "base/macros.h" |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 13 | #include "base/run_loop.h" |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 14 | #include "base/stl_util.h" |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 15 | #include "base/strings/string_number_conversions.h" |
Bence Béky | d74f438 | 2018-02-20 18:26:19 | [diff] [blame] | 16 | #include "base/strings/string_piece.h" |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 17 | #include "base/strings/stringprintf.h" |
Devlin Cronin | e4bcb40e | 2018-06-05 18:02:47 | [diff] [blame] | 18 | #include "base/test/metrics/histogram_tester.h" |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 19 | #include "net/base/chunked_upload_data_stream.h" |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 20 | #include "net/base/completion_once_callback.h" |
mgersh | af9a923 | 2017-04-13 20:19:03 | [diff] [blame] | 21 | #include "net/base/mock_network_change_notifier.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 22 | #include "net/base/test_completion_callback.h" |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 23 | #include "net/base/test_proxy_delegate.h" |
rsleevi | d6de830 | 2016-06-21 01:33:20 | [diff] [blame] | 24 | #include "net/cert/ct_policy_enforcer.h" |
[email protected] | 6e7845ae | 2013-03-29 21:48:11 | [diff] [blame] | 25 | #include "net/cert/mock_cert_verifier.h" |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 26 | #include "net/cert/multi_log_ct_verifier.h" |
[email protected] | f2cb3cf | 2013-03-21 01:40:53 | [diff] [blame] | 27 | #include "net/dns/mock_host_resolver.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 28 | #include "net/http/http_auth_handler_factory.h" |
| 29 | #include "net/http/http_network_session.h" |
| 30 | #include "net/http/http_network_transaction.h" |
| 31 | #include "net/http/http_server_properties_impl.h" |
| 32 | #include "net/http/http_stream.h" |
| 33 | #include "net/http/http_stream_factory.h" |
[email protected] | c41737d | 2014-05-14 07:47:19 | [diff] [blame] | 34 | #include "net/http/http_transaction_test_util.h" |
[email protected] | b1c988b | 2013-06-13 06:48:11 | [diff] [blame] | 35 | #include "net/http/transport_security_state.h" |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 36 | #include "net/log/net_log_event_type.h" |
vishal.b | 62985ca9 | 2015-04-17 08:45:51 | [diff] [blame] | 37 | #include "net/log/test_net_log.h" |
mmenke | 43758e6 | 2015-05-04 21:09:46 | [diff] [blame] | 38 | #include "net/log/test_net_log_entry.h" |
| 39 | #include "net/log/test_net_log_util.h" |
Lily Houghton | 582d462 | 2018-01-22 22:43:40 | [diff] [blame] | 40 | #include "net/proxy_resolution/proxy_config_service_fixed.h" |
Lily Houghton | ffe89daa0 | 2018-03-09 18:30:03 | [diff] [blame] | 41 | #include "net/proxy_resolution/proxy_resolution_service.h" |
Lily Houghton | 582d462 | 2018-01-22 22:43:40 | [diff] [blame] | 42 | #include "net/proxy_resolution/proxy_resolver.h" |
Ryan Hamilton | a3ee93a7 | 2018-08-01 22:03:08 | [diff] [blame] | 43 | #include "net/quic/crypto/proof_verifier_chromium.h" |
| 44 | #include "net/quic/mock_crypto_client_stream_factory.h" |
| 45 | #include "net/quic/mock_quic_data.h" |
| 46 | #include "net/quic/quic_chromium_alarm_factory.h" |
| 47 | #include "net/quic/quic_http_stream.h" |
| 48 | #include "net/quic/quic_http_utils.h" |
| 49 | #include "net/quic/quic_stream_factory_peer.h" |
| 50 | #include "net/quic/quic_test_packet_maker.h" |
| 51 | #include "net/quic/test_task_runner.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 52 | #include "net/socket/client_socket_factory.h" |
| 53 | #include "net/socket/mock_client_socket_pool_manager.h" |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 54 | #include "net/socket/next_proto.h" |
tbansal | ca83c00 | 2016-04-28 20:56:28 | [diff] [blame] | 55 | #include "net/socket/socket_performance_watcher.h" |
| 56 | #include "net/socket/socket_performance_watcher_factory.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 57 | #include "net/socket/socket_test_util.h" |
Bence Béky | 94658bf | 2018-05-11 19:22:58 | [diff] [blame] | 58 | #include "net/spdy/spdy_test_util_common.h" |
[email protected] | 536fd0b | 2013-03-14 17:41:57 | [diff] [blame] | 59 | #include "net/ssl/ssl_config_service_defaults.h" |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 60 | #include "net/test/cert_test_util.h" |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 61 | #include "net/test/gtest_util.h" |
rsleevi | a69c79a | 2016-06-22 03:28:43 | [diff] [blame] | 62 | #include "net/test/test_data_directory.h" |
Bence Béky | 98447b1 | 2018-05-08 03:14:01 | [diff] [blame] | 63 | #include "net/test/test_with_scoped_task_environment.h" |
Ryan Hamilton | 56b10c5d | 2018-05-11 13:40:16 | [diff] [blame] | 64 | #include "net/third_party/quic/core/crypto/quic_decrypter.h" |
| 65 | #include "net/third_party/quic/core/crypto/quic_encrypter.h" |
| 66 | #include "net/third_party/quic/core/quic_framer.h" |
| 67 | #include "net/third_party/quic/platform/api/quic_str_cat.h" |
| 68 | #include "net/third_party/quic/platform/api/quic_string_piece.h" |
| 69 | #include "net/third_party/quic/platform/api/quic_test.h" |
| 70 | #include "net/third_party/quic/test_tools/crypto_test_utils.h" |
| 71 | #include "net/third_party/quic/test_tools/mock_clock.h" |
| 72 | #include "net/third_party/quic/test_tools/mock_random.h" |
| 73 | #include "net/third_party/quic/test_tools/quic_spdy_session_peer.h" |
| 74 | #include "net/third_party/quic/test_tools/quic_test_utils.h" |
Ryan Hamilton | 2e003eea | 2018-05-02 00:24:29 | [diff] [blame] | 75 | #include "net/third_party/spdy/core/spdy_frame_builder.h" |
| 76 | #include "net/third_party/spdy/core/spdy_framer.h" |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 77 | #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 78 | #include "net/url_request/url_request.h" |
| 79 | #include "net/url_request/url_request_job_factory_impl.h" |
| 80 | #include "net/url_request/url_request_test_util.h" |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 81 | #include "testing/gmock/include/gmock/gmock.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 82 | #include "testing/gtest/include/gtest/gtest.h" |
| 83 | #include "testing/platform_test.h" |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 84 | #include "url/gurl.h" |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 85 | |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 86 | using ::testing::ElementsAre; |
| 87 | using ::testing::Key; |
| 88 | |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 89 | namespace net { |
| 90 | namespace test { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 91 | |
| 92 | namespace { |
| 93 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 94 | enum DestinationType { |
| 95 | // In pooling tests with two requests for different origins to the same |
| 96 | // destination, the destination should be |
| 97 | SAME_AS_FIRST, // the same as the first origin, |
| 98 | SAME_AS_SECOND, // the same as the second origin, or |
| 99 | DIFFERENT, // different from both. |
| 100 | }; |
| 101 | |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 102 | static const char kQuicAlternativeServiceHeader[] = |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 103 | "Alt-Svc: quic=\":443\"\r\n\r\n"; |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 104 | static const char kQuicAlternativeServiceWithProbabilityHeader[] = |
| 105 | "Alt-Svc: quic=\":443\";p=\".5\"\r\n\r\n"; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 106 | static const char kQuicAlternativeServiceDifferentPortHeader[] = |
| 107 | "Alt-Svc: quic=\":137\"\r\n\r\n"; |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 108 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 109 | const char kDefaultServerHostName[] = "mail.example.org"; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 110 | const char kDifferentHostname[] = "different.example.com"; |
| 111 | |
| 112 | // Run QuicNetworkTransactionWithDestinationTest instances with all value |
| 113 | // combinations of version and destination_type. |
| 114 | struct PoolingTestParams { |
| 115 | friend std::ostream& operator<<(std::ostream& os, |
| 116 | const PoolingTestParams& p) { |
| 117 | os << "{ version: " << QuicVersionToString(p.version) |
| 118 | << ", destination_type: "; |
| 119 | switch (p.destination_type) { |
| 120 | case SAME_AS_FIRST: |
| 121 | os << "SAME_AS_FIRST"; |
| 122 | break; |
| 123 | case SAME_AS_SECOND: |
| 124 | os << "SAME_AS_SECOND"; |
| 125 | break; |
| 126 | case DIFFERENT: |
| 127 | os << "DIFFERENT"; |
| 128 | break; |
| 129 | } |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 130 | os << ", client_headers_include_h2_stream_dependency: " |
| 131 | << p.client_headers_include_h2_stream_dependency; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 132 | os << " }"; |
| 133 | return os; |
| 134 | } |
| 135 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 136 | quic::QuicTransportVersion version; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 137 | DestinationType destination_type; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 138 | bool client_headers_include_h2_stream_dependency; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 139 | }; |
| 140 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 141 | std::string GenerateQuicVersionsListForAltSvcHeader( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 142 | const quic::QuicTransportVersionVector& versions) { |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 143 | std::string result = ""; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 144 | for (const quic::QuicTransportVersion& version : versions) { |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 145 | if (!result.empty()) |
| 146 | result.append(","); |
| 147 | result.append(base::IntToString(version)); |
| 148 | } |
| 149 | return result; |
| 150 | } |
| 151 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 152 | std::vector<PoolingTestParams> GetPoolingTestParams() { |
| 153 | std::vector<PoolingTestParams> params; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 154 | quic::QuicTransportVersionVector all_supported_versions = |
| 155 | quic::AllSupportedTransportVersions(); |
| 156 | for (const quic::QuicTransportVersion version : all_supported_versions) { |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 157 | params.push_back(PoolingTestParams{version, SAME_AS_FIRST, false}); |
| 158 | params.push_back(PoolingTestParams{version, SAME_AS_FIRST, true}); |
| 159 | params.push_back(PoolingTestParams{version, SAME_AS_SECOND, false}); |
| 160 | params.push_back(PoolingTestParams{version, SAME_AS_SECOND, true}); |
| 161 | params.push_back(PoolingTestParams{version, DIFFERENT, false}); |
| 162 | params.push_back(PoolingTestParams{version, DIFFERENT, true}); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 163 | } |
| 164 | return params; |
| 165 | } |
bnc | b07c0553 | 2015-05-14 19:07:20 | [diff] [blame] | 166 | |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 167 | } // namespace |
| 168 | |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 169 | class HeadersHandler { |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 170 | public: |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 171 | HeadersHandler() : was_proxied_(false) {} |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 172 | |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 173 | bool was_proxied() { return was_proxied_; } |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 174 | |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 175 | void OnBeforeHeadersSent(const ProxyInfo& proxy_info, |
| 176 | HttpRequestHeaders* request_headers) { |
| 177 | if (!proxy_info.is_http() && !proxy_info.is_https() && |
| 178 | !proxy_info.is_quic()) { |
| 179 | return; |
| 180 | } |
| 181 | was_proxied_ = true; |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | private: |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 185 | bool was_proxied_; |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 186 | }; |
| 187 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 188 | class TestSocketPerformanceWatcher : public SocketPerformanceWatcher { |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 189 | public: |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 190 | TestSocketPerformanceWatcher(bool* should_notify_updated_rtt, |
| 191 | bool* rtt_notification_received) |
| 192 | : should_notify_updated_rtt_(should_notify_updated_rtt), |
| 193 | rtt_notification_received_(rtt_notification_received) {} |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 194 | ~TestSocketPerformanceWatcher() override {} |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 195 | |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 196 | bool ShouldNotifyUpdatedRTT() const override { |
| 197 | return *should_notify_updated_rtt_; |
| 198 | } |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 199 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 200 | void OnUpdatedRTTAvailable(const base::TimeDelta& rtt) override { |
| 201 | *rtt_notification_received_ = true; |
| 202 | } |
| 203 | |
| 204 | void OnConnectionChanged() override {} |
| 205 | |
| 206 | private: |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 207 | bool* should_notify_updated_rtt_; |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 208 | bool* rtt_notification_received_; |
| 209 | |
| 210 | DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcher); |
| 211 | }; |
| 212 | |
| 213 | class TestSocketPerformanceWatcherFactory |
| 214 | : public SocketPerformanceWatcherFactory { |
| 215 | public: |
| 216 | TestSocketPerformanceWatcherFactory() |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 217 | : watcher_count_(0u), |
| 218 | should_notify_updated_rtt_(true), |
| 219 | rtt_notification_received_(false) {} |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 220 | ~TestSocketPerformanceWatcherFactory() override {} |
| 221 | |
| 222 | // SocketPerformanceWatcherFactory implementation: |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 223 | std::unique_ptr<SocketPerformanceWatcher> CreateSocketPerformanceWatcher( |
Tarun Bansal | 73a0437 | 2017-07-27 16:28:41 | [diff] [blame] | 224 | const Protocol protocol, |
| 225 | const AddressList& /* address_list */) override { |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 226 | if (protocol != PROTOCOL_QUIC) { |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 227 | return nullptr; |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 228 | } |
| 229 | ++watcher_count_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 230 | return std::unique_ptr<SocketPerformanceWatcher>( |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 231 | new TestSocketPerformanceWatcher(&should_notify_updated_rtt_, |
| 232 | &rtt_notification_received_)); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 233 | } |
| 234 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 235 | size_t watcher_count() const { return watcher_count_; } |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 236 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 237 | bool rtt_notification_received() const { return rtt_notification_received_; } |
| 238 | |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 239 | void set_should_notify_updated_rtt(bool should_notify_updated_rtt) { |
| 240 | should_notify_updated_rtt_ = should_notify_updated_rtt; |
| 241 | } |
| 242 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 243 | private: |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 244 | size_t watcher_count_; |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 245 | bool should_notify_updated_rtt_; |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 246 | bool rtt_notification_received_; |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 247 | |
| 248 | DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcherFactory); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 249 | }; |
| 250 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 251 | class QuicNetworkTransactionTest |
| 252 | : public PlatformTest, |
| 253 | public ::testing::WithParamInterface< |
| 254 | std::tuple<quic::QuicTransportVersion, bool>>, |
| 255 | public WithScopedTaskEnvironment { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 256 | protected: |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 257 | QuicNetworkTransactionTest() |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 258 | : version_(std::get<0>(GetParam())), |
| 259 | client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 260 | supported_versions_(quic::test::SupportedTransportVersions(version_)), |
bnc | 90be5dd78 | 2016-11-09 16:28:44 | [diff] [blame] | 261 | client_maker_(version_, |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 262 | 0, |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 263 | &clock_, |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 264 | kDefaultServerHostName, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 265 | quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 266 | client_headers_include_h2_stream_dependency_), |
bnc | 90be5dd78 | 2016-11-09 16:28:44 | [diff] [blame] | 267 | server_maker_(version_, |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 268 | 0, |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 269 | &clock_, |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 270 | kDefaultServerHostName, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 271 | quic::Perspective::IS_SERVER, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 272 | false), |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 273 | cert_transparency_verifier_(new MultiLogCTVerifier()), |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 274 | ssl_config_service_(new SSLConfigServiceDefaults), |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 275 | proxy_resolution_service_(ProxyResolutionService::CreateDirect()), |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 276 | auth_handler_factory_( |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 277 | HttpAuthHandlerFactory::CreateDefault(&host_resolver_)), |
[email protected] | 457d695 | 2013-12-13 09:24:58 | [diff] [blame] | 278 | random_generator_(0), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 279 | ssl_data_(ASYNC, OK) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 280 | request_.method = "GET"; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 281 | std::string url("https://"); |
bnc | b07c0553 | 2015-05-14 19:07:20 | [diff] [blame] | 282 | url.append(kDefaultServerHostName); |
| 283 | request_.url = GURL(url); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 284 | request_.load_flags = 0; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 285 | request_.traffic_annotation = |
| 286 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 287 | clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20)); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 288 | |
| 289 | scoped_refptr<X509Certificate> cert( |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 290 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 291 | verify_details_.cert_verify_result.verified_cert = cert; |
| 292 | verify_details_.cert_verify_result.is_issued_by_known_root = true; |
| 293 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 294 | } |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 295 | |
dcheng | 67be2b1f | 2014-10-27 21:47:29 | [diff] [blame] | 296 | void SetUp() override { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 297 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 298 | base::RunLoop().RunUntilIdle(); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 299 | } |
| 300 | |
dcheng | 67be2b1f | 2014-10-27 21:47:29 | [diff] [blame] | 301 | void TearDown() override { |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 302 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 303 | // Empty the current queue. |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 304 | base::RunLoop().RunUntilIdle(); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 305 | PlatformTest::TearDown(); |
| 306 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 307 | base::RunLoop().RunUntilIdle(); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 308 | session_.reset(); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 309 | } |
| 310 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 311 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 312 | ConstructClientConnectionClosePacket(quic::QuicPacketNumber num) { |
Bin Wu | 5311aca | 2018-01-22 01:19:03 | [diff] [blame] | 313 | return client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 314 | num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 315 | } |
| 316 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 317 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 318 | ConstructServerConnectionClosePacket(quic::QuicPacketNumber num) { |
Bin Wu | 5311aca | 2018-01-22 01:19:03 | [diff] [blame] | 319 | return server_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 320 | num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"); |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 321 | } |
| 322 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 323 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerGoAwayPacket( |
| 324 | quic::QuicPacketNumber num, |
| 325 | quic::QuicErrorCode error_code, |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 326 | std::string reason_phrase) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 327 | return server_maker_.MakeGoAwayPacket(num, error_code, reason_phrase); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 328 | } |
| 329 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 330 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
| 331 | quic::QuicPacketNumber packet_number, |
| 332 | quic::QuicPacketNumber largest_received, |
| 333 | quic::QuicPacketNumber smallest_received, |
| 334 | quic::QuicPacketNumber least_unacked) { |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 335 | return client_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 336 | smallest_received, least_unacked, true); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 337 | } |
| 338 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 339 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
| 340 | quic::QuicPacketNumber packet_number, |
| 341 | quic::QuicPacketNumber largest_received, |
| 342 | quic::QuicPacketNumber smallest_received, |
| 343 | quic::QuicPacketNumber least_unacked, |
| 344 | quic::QuicTime::Delta ack_delay_time) { |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 345 | return client_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 346 | smallest_received, least_unacked, true, |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 347 | ack_delay_time); |
| 348 | } |
| 349 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 350 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckAndRstPacket( |
| 351 | quic::QuicPacketNumber num, |
| 352 | quic::QuicStreamId stream_id, |
| 353 | quic::QuicRstStreamErrorCode error_code, |
| 354 | quic::QuicPacketNumber largest_received, |
| 355 | quic::QuicPacketNumber smallest_received, |
| 356 | quic::QuicPacketNumber least_unacked) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 357 | return client_maker_.MakeAckAndRstPacket( |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 358 | num, false, stream_id, error_code, largest_received, smallest_received, |
| 359 | least_unacked, true); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 360 | } |
| 361 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 362 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientRstPacket( |
| 363 | quic::QuicPacketNumber num, |
| 364 | quic::QuicStreamId stream_id, |
| 365 | quic::QuicRstStreamErrorCode error_code, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 366 | size_t bytes_written) { |
| 367 | return client_maker_.MakeRstPacket(num, false, stream_id, error_code, |
| 368 | bytes_written); |
| 369 | } |
| 370 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 371 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 372 | ConstructClientAckAndConnectionClosePacket( |
| 373 | quic::QuicPacketNumber packet_number, |
| 374 | quic::QuicPacketNumber largest_received, |
| 375 | quic::QuicPacketNumber smallest_received, |
| 376 | quic::QuicPacketNumber least_unacked) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 377 | return client_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 378 | smallest_received, least_unacked, true); |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 379 | } |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 380 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 381 | std::unique_ptr<quic::QuicEncryptedPacket> |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 382 | ConstructClientAckAndConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 383 | quic::QuicPacketNumber num, |
| 384 | quic::QuicTime::Delta delta_time_largest_observed, |
| 385 | quic::QuicPacketNumber largest_received, |
| 386 | quic::QuicPacketNumber smallest_received, |
| 387 | quic::QuicPacketNumber least_unacked, |
| 388 | quic::QuicErrorCode quic_error, |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 389 | const std::string& quic_error_details) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 390 | return client_maker_.MakeAckAndConnectionClosePacket( |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 391 | num, false, delta_time_largest_observed, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 392 | smallest_received, least_unacked, quic_error, quic_error_details); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 393 | } |
| 394 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 395 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerRstPacket( |
| 396 | quic::QuicPacketNumber num, |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 397 | bool include_version, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 398 | quic::QuicStreamId stream_id, |
| 399 | quic::QuicRstStreamErrorCode error_code) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 400 | return server_maker_.MakeRstPacket(num, include_version, stream_id, |
| 401 | error_code); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 402 | } |
| 403 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 404 | std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket( |
| 405 | quic::QuicPacketNumber packet_number, |
| 406 | quic::QuicStreamOffset* offset) { |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 407 | return client_maker_.MakeInitialSettingsPacket(packet_number, offset); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 408 | } |
| 409 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 410 | std::unique_ptr<quic::QuicReceivedPacket> ConstructServerAckPacket( |
| 411 | quic::QuicPacketNumber packet_number, |
| 412 | quic::QuicPacketNumber largest_received, |
| 413 | quic::QuicPacketNumber smallest_received, |
| 414 | quic::QuicPacketNumber least_unacked) { |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 415 | return server_maker_.MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 416 | smallest_received, least_unacked, false); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 417 | } |
| 418 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 419 | std::unique_ptr<quic::QuicReceivedPacket> ConstructClientPriorityPacket( |
| 420 | quic::QuicPacketNumber packet_number, |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 421 | bool should_include_version, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 422 | quic::QuicStreamId id, |
| 423 | quic::QuicStreamId parent_stream_id, |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 424 | RequestPriority request_priority, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 425 | quic::QuicStreamOffset* offset) { |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 426 | return client_maker_.MakePriorityPacket( |
| 427 | packet_number, should_include_version, id, parent_stream_id, |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 428 | ConvertRequestPriorityToQuicPriority(request_priority), offset); |
| 429 | } |
| 430 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 431 | std::unique_ptr<quic::QuicEncryptedPacket> |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 432 | ConstructClientAckAndPriorityFramesPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 433 | quic::QuicPacketNumber packet_number, |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 434 | bool should_include_version, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 435 | quic::QuicPacketNumber largest_received, |
| 436 | quic::QuicPacketNumber smallest_received, |
| 437 | quic::QuicPacketNumber least_unacked, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 438 | const std::vector<QuicTestPacketMaker::Http2StreamDependency>& |
| 439 | priority_frames, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 440 | quic::QuicStreamOffset* offset) { |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 441 | return client_maker_.MakeAckAndMultiplePriorityFramesPacket( |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 442 | packet_number, should_include_version, largest_received, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 443 | smallest_received, least_unacked, priority_frames, offset); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 444 | } |
| 445 | |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 446 | // Uses default QuicTestPacketMaker. |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 447 | spdy::SpdyHeaderBlock GetRequestHeaders(const std::string& method, |
| 448 | const std::string& scheme, |
| 449 | const std::string& path) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 450 | return GetRequestHeaders(method, scheme, path, &client_maker_); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 451 | } |
| 452 | |
| 453 | // Uses customized QuicTestPacketMaker. |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 454 | spdy::SpdyHeaderBlock GetRequestHeaders(const std::string& method, |
| 455 | const std::string& scheme, |
| 456 | const std::string& path, |
| 457 | QuicTestPacketMaker* maker) { |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 458 | return maker->GetRequestHeaders(method, scheme, path); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 459 | } |
| 460 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 461 | spdy::SpdyHeaderBlock ConnectRequestHeaders(const std::string& host_port) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 462 | return client_maker_.ConnectRequestHeaders(host_port); |
| 463 | } |
| 464 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 465 | spdy::SpdyHeaderBlock GetResponseHeaders(const std::string& status) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 466 | return server_maker_.GetResponseHeaders(status); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 467 | } |
| 468 | |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 469 | // Appends alt_svc headers in the response headers. |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 470 | spdy::SpdyHeaderBlock GetResponseHeaders(const std::string& status, |
| 471 | const std::string& alt_svc) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 472 | return server_maker_.GetResponseHeaders(status, alt_svc); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 473 | } |
| 474 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 475 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket( |
| 476 | quic::QuicPacketNumber packet_number, |
| 477 | quic::QuicStreamId stream_id, |
[email protected] | e8ff2684 | 2013-03-22 21:02:05 | [diff] [blame] | 478 | bool should_include_version, |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 479 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 480 | quic::QuicStreamOffset offset, |
| 481 | quic::QuicStringPiece data) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 482 | return server_maker_.MakeDataPacket( |
| 483 | packet_number, stream_id, should_include_version, fin, offset, data); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 484 | } |
| 485 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 486 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientDataPacket( |
| 487 | quic::QuicPacketNumber packet_number, |
| 488 | quic::QuicStreamId stream_id, |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 489 | bool should_include_version, |
| 490 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 491 | quic::QuicStreamOffset offset, |
| 492 | quic::QuicStringPiece data) { |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 493 | return client_maker_.MakeDataPacket( |
| 494 | packet_number, stream_id, should_include_version, fin, offset, data); |
| 495 | } |
| 496 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 497 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckAndDataPacket( |
| 498 | quic::QuicPacketNumber packet_number, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 499 | bool include_version, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 500 | quic::QuicStreamId stream_id, |
| 501 | quic::QuicPacketNumber largest_received, |
| 502 | quic::QuicPacketNumber smallest_received, |
| 503 | quic::QuicPacketNumber least_unacked, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 504 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 505 | quic::QuicStreamOffset offset, |
| 506 | quic::QuicStringPiece data) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 507 | return client_maker_.MakeAckAndDataPacket( |
| 508 | packet_number, include_version, stream_id, largest_received, |
| 509 | smallest_received, least_unacked, fin, offset, data); |
| 510 | } |
| 511 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 512 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientForceHolDataPacket( |
| 513 | quic::QuicPacketNumber packet_number, |
| 514 | quic::QuicStreamId stream_id, |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 515 | bool should_include_version, |
| 516 | bool fin, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 517 | quic::QuicStreamOffset* offset, |
| 518 | quic::QuicStringPiece data) { |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 519 | return client_maker_.MakeForceHolDataPacket( |
| 520 | packet_number, stream_id, should_include_version, fin, offset, data); |
| 521 | } |
| 522 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 523 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 524 | ConstructClientRequestHeadersPacket(quic::QuicPacketNumber packet_number, |
| 525 | quic::QuicStreamId stream_id, |
| 526 | bool should_include_version, |
| 527 | bool fin, |
| 528 | spdy::SpdyHeaderBlock headers) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 529 | return ConstructClientRequestHeadersPacket(packet_number, stream_id, |
| 530 | should_include_version, fin, |
| 531 | std::move(headers), nullptr); |
| 532 | } |
| 533 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 534 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 535 | ConstructClientRequestHeadersPacket(quic::QuicPacketNumber packet_number, |
| 536 | quic::QuicStreamId stream_id, |
| 537 | bool should_include_version, |
| 538 | bool fin, |
| 539 | spdy::SpdyHeaderBlock headers, |
| 540 | quic::QuicStreamOffset* offset) { |
Yixin Wang | 7a3f1b8d | 2018-01-17 21:40:48 | [diff] [blame] | 541 | return ConstructClientRequestHeadersPacket(packet_number, stream_id, |
| 542 | should_include_version, fin, |
| 543 | std::move(headers), 0, offset); |
| 544 | } |
| 545 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 546 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 547 | ConstructClientRequestHeadersPacket(quic::QuicPacketNumber packet_number, |
| 548 | quic::QuicStreamId stream_id, |
| 549 | bool should_include_version, |
| 550 | bool fin, |
| 551 | spdy::SpdyHeaderBlock headers, |
| 552 | quic::QuicStreamId parent_stream_id, |
| 553 | quic::QuicStreamOffset* offset) { |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 554 | return ConstructClientRequestHeadersPacket( |
| 555 | packet_number, stream_id, should_include_version, fin, DEFAULT_PRIORITY, |
Yixin Wang | 7a3f1b8d | 2018-01-17 21:40:48 | [diff] [blame] | 556 | std::move(headers), parent_stream_id, offset); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 557 | } |
| 558 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 559 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 560 | ConstructClientRequestHeadersPacket(quic::QuicPacketNumber packet_number, |
| 561 | quic::QuicStreamId stream_id, |
| 562 | bool should_include_version, |
| 563 | bool fin, |
| 564 | RequestPriority request_priority, |
| 565 | spdy::SpdyHeaderBlock headers, |
| 566 | quic::QuicStreamId parent_stream_id, |
| 567 | quic::QuicStreamOffset* offset) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 568 | spdy::SpdyPriority priority = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 569 | ConvertRequestPriorityToQuicPriority(request_priority); |
| 570 | return client_maker_.MakeRequestHeadersPacketWithOffsetTracking( |
| 571 | packet_number, stream_id, should_include_version, fin, priority, |
| 572 | std::move(headers), parent_stream_id, offset); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 573 | } |
| 574 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 575 | std::unique_ptr<quic::QuicReceivedPacket> |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 576 | ConstructClientRequestHeadersAndDataFramesPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 577 | quic::QuicPacketNumber packet_number, |
| 578 | quic::QuicStreamId stream_id, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 579 | bool should_include_version, |
| 580 | bool fin, |
| 581 | RequestPriority request_priority, |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 582 | spdy::SpdyHeaderBlock headers, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 583 | quic::QuicStreamId parent_stream_id, |
| 584 | quic::QuicStreamOffset* offset, |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 585 | size_t* spdy_headers_frame_length, |
| 586 | const std::vector<std::string>& data_writes) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 587 | spdy::SpdyPriority priority = |
Yixin Wang | e7ecc47 | 2018-03-06 19:00:25 | [diff] [blame] | 588 | ConvertRequestPriorityToQuicPriority(request_priority); |
| 589 | return client_maker_.MakeRequestHeadersAndMultipleDataFramesPacket( |
| 590 | packet_number, stream_id, should_include_version, fin, priority, |
| 591 | std::move(headers), parent_stream_id, offset, spdy_headers_frame_length, |
| 592 | data_writes); |
| 593 | } |
| 594 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 595 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 596 | ConstructClientMultipleDataFramesPacket(quic::QuicPacketNumber packet_number, |
| 597 | quic::QuicStreamId stream_id, |
| 598 | bool should_include_version, |
| 599 | bool fin, |
| 600 | const std::vector<std::string>& data, |
| 601 | quic::QuicStreamOffset offset) { |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 602 | return client_maker_.MakeMultipleDataFramesPacket( |
| 603 | packet_number, stream_id, should_include_version, fin, offset, data); |
| 604 | } |
| 605 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 606 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerPushPromisePacket( |
| 607 | quic::QuicPacketNumber packet_number, |
| 608 | quic::QuicStreamId stream_id, |
| 609 | quic::QuicStreamId promised_stream_id, |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 610 | bool should_include_version, |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 611 | spdy::SpdyHeaderBlock headers, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 612 | quic::QuicStreamOffset* offset, |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 613 | QuicTestPacketMaker* maker) { |
| 614 | return maker->MakePushPromisePacket( |
| 615 | packet_number, stream_id, promised_stream_id, should_include_version, |
| 616 | false, std::move(headers), nullptr, offset); |
| 617 | } |
| 618 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 619 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 620 | ConstructServerResponseHeadersPacket(quic::QuicPacketNumber packet_number, |
| 621 | quic::QuicStreamId stream_id, |
| 622 | bool should_include_version, |
| 623 | bool fin, |
| 624 | spdy::SpdyHeaderBlock headers) { |
zhongyi | 76cfa760 | 2016-07-12 19:56:27 | [diff] [blame] | 625 | return ConstructServerResponseHeadersPacket(packet_number, stream_id, |
| 626 | should_include_version, fin, |
| 627 | std::move(headers), nullptr); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 628 | } |
| 629 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 630 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 631 | ConstructServerResponseHeadersPacket(quic::QuicPacketNumber packet_number, |
| 632 | quic::QuicStreamId stream_id, |
| 633 | bool should_include_version, |
| 634 | bool fin, |
| 635 | spdy::SpdyHeaderBlock headers, |
| 636 | quic::QuicStreamOffset* offset) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 637 | return server_maker_.MakeResponseHeadersPacketWithOffsetTracking( |
bnc | 94893a7 | 2016-06-30 13:45:25 | [diff] [blame] | 638 | packet_number, stream_id, should_include_version, fin, |
| 639 | std::move(headers), offset); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 640 | } |
| 641 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 642 | void CreateSession( |
| 643 | const quic::QuicTransportVersionVector& supported_versions) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 644 | session_params_.enable_quic = true; |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 645 | session_params_.quic_supported_versions = supported_versions; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 646 | session_params_.quic_headers_include_h2_stream_dependency = |
| 647 | client_headers_include_h2_stream_dependency_; |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 648 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 649 | session_context_.quic_clock = &clock_; |
| 650 | session_context_.quic_random = &random_generator_; |
| 651 | session_context_.client_socket_factory = &socket_factory_; |
| 652 | session_context_.quic_crypto_client_stream_factory = |
| 653 | &crypto_client_stream_factory_; |
| 654 | session_context_.host_resolver = &host_resolver_; |
| 655 | session_context_.cert_verifier = &cert_verifier_; |
| 656 | session_context_.transport_security_state = &transport_security_state_; |
| 657 | session_context_.cert_transparency_verifier = |
| 658 | cert_transparency_verifier_.get(); |
| 659 | session_context_.ct_policy_enforcer = &ct_policy_enforcer_; |
| 660 | session_context_.socket_performance_watcher_factory = |
| 661 | &test_socket_performance_watcher_factory_; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 662 | session_context_.proxy_resolution_service = proxy_resolution_service_.get(); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 663 | session_context_.ssl_config_service = ssl_config_service_.get(); |
| 664 | session_context_.http_auth_handler_factory = auth_handler_factory_.get(); |
| 665 | session_context_.http_server_properties = &http_server_properties_; |
| 666 | session_context_.net_log = net_log_.bound().net_log(); |
| 667 | |
| 668 | session_.reset(new HttpNetworkSession(session_params_, session_context_)); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 669 | session_->quic_stream_factory()->set_require_confirmation(false); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 670 | SpdySessionPoolPeer spdy_pool_peer(session_->spdy_session_pool()); |
| 671 | spdy_pool_peer.SetEnableSendingInitialData(false); |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 672 | } |
| 673 | |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 674 | void CreateSession() { return CreateSession(supported_versions_); } |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 675 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 676 | void CheckWasQuicResponse(HttpNetworkTransaction* trans) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 677 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 678 | ASSERT_TRUE(response != nullptr); |
| 679 | ASSERT_TRUE(response->headers.get() != nullptr); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 680 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 681 | EXPECT_TRUE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 682 | EXPECT_TRUE(response->was_alpn_negotiated); |
bnc | 90be5dd78 | 2016-11-09 16:28:44 | [diff] [blame] | 683 | EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_), |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 684 | response->connection_info); |
| 685 | } |
| 686 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 687 | void CheckResponsePort(HttpNetworkTransaction* trans, uint16_t port) { |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 688 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 689 | ASSERT_TRUE(response != nullptr); |
| 690 | EXPECT_EQ(port, response->socket_address.port()); |
| 691 | } |
| 692 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 693 | void CheckWasHttpResponse(HttpNetworkTransaction* trans) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 694 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 695 | ASSERT_TRUE(response != nullptr); |
| 696 | ASSERT_TRUE(response->headers.get() != nullptr); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 697 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 698 | EXPECT_FALSE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 699 | EXPECT_FALSE(response->was_alpn_negotiated); |
mmenke | 8210acc | 2016-07-11 16:34:52 | [diff] [blame] | 700 | EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1_1, |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 701 | response->connection_info); |
| 702 | } |
| 703 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 704 | void CheckWasSpdyResponse(HttpNetworkTransaction* trans) { |
| 705 | const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 706 | ASSERT_TRUE(response != nullptr); |
| 707 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 708 | EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); |
| 709 | EXPECT_TRUE(response->was_fetched_via_spdy); |
| 710 | EXPECT_TRUE(response->was_alpn_negotiated); |
| 711 | EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP2, |
| 712 | response->connection_info); |
| 713 | } |
| 714 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 715 | void CheckResponseData(HttpNetworkTransaction* trans, |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 716 | const std::string& expected) { |
| 717 | std::string response_data; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 718 | ASSERT_THAT(ReadTransaction(trans, &response_data), IsOk()); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 719 | EXPECT_EQ(expected, response_data); |
| 720 | } |
| 721 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 722 | void RunTransaction(HttpNetworkTransaction* trans) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 723 | TestCompletionCallback callback; |
| 724 | int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 725 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 726 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 727 | } |
| 728 | |
| 729 | void SendRequestAndExpectHttpResponse(const std::string& expected) { |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 730 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 731 | RunTransaction(&trans); |
| 732 | CheckWasHttpResponse(&trans); |
| 733 | CheckResponseData(&trans, expected); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 734 | } |
| 735 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 736 | void SendRequestAndExpectHttpResponseFromProxy(const std::string& expected, |
| 737 | bool used_proxy, |
| 738 | uint16_t port) { |
| 739 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 740 | HeadersHandler headers_handler; |
| 741 | trans.SetBeforeHeadersSentCallback( |
| 742 | base::Bind(&HeadersHandler::OnBeforeHeadersSent, |
| 743 | base::Unretained(&headers_handler))); |
| 744 | RunTransaction(&trans); |
| 745 | CheckWasHttpResponse(&trans); |
| 746 | CheckResponsePort(&trans, port); |
| 747 | CheckResponseData(&trans, expected); |
| 748 | EXPECT_EQ(used_proxy, headers_handler.was_proxied()); |
tbansal | 2ecbbc7 | 2016-10-06 17:15:47 | [diff] [blame] | 749 | if (used_proxy) { |
| 750 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_https()); |
| 751 | } else { |
| 752 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_direct()); |
| 753 | } |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 754 | } |
| 755 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 756 | void SendRequestAndExpectQuicResponse(const std::string& expected) { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 757 | SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, 443); |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 758 | } |
| 759 | |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 760 | void SendRequestAndExpectQuicResponseFromProxyOnPort( |
| 761 | const std::string& expected, |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 762 | uint16_t port) { |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 763 | SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 764 | } |
| 765 | |
| 766 | void AddQuicAlternateProtocolMapping( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 767 | MockCryptoClientStream::HandshakeMode handshake_mode) { |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 768 | crypto_client_stream_factory_.set_handshake_mode(handshake_mode); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 769 | url::SchemeHostPort server(request_.url); |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 770 | AlternativeService alternative_service(kProtoQUIC, server.host(), 443); |
bnc | 7dc7e1b4 | 2015-07-28 14:43:12 | [diff] [blame] | 771 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 772 | http_server_properties_.SetQuicAlternativeService( |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 773 | server, alternative_service, expiration, supported_versions_); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 774 | } |
| 775 | |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 776 | void AddQuicRemoteAlternativeServiceMapping( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 777 | MockCryptoClientStream::HandshakeMode handshake_mode, |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 778 | const HostPortPair& alternative) { |
| 779 | crypto_client_stream_factory_.set_handshake_mode(handshake_mode); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 780 | url::SchemeHostPort server(request_.url); |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 781 | AlternativeService alternative_service(kProtoQUIC, alternative.host(), |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 782 | alternative.port()); |
| 783 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 784 | http_server_properties_.SetQuicAlternativeService( |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 785 | server, alternative_service, expiration, supported_versions_); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 786 | } |
| 787 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 788 | void ExpectBrokenAlternateProtocolMapping() { |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 789 | const url::SchemeHostPort server(request_.url); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 790 | const AlternativeServiceInfoVector alternative_service_info_vector = |
| 791 | http_server_properties_.GetAlternativeServiceInfos(server); |
| 792 | EXPECT_EQ(1u, alternative_service_info_vector.size()); |
bnc | 6be245c1 | 2015-05-15 11:24:07 | [diff] [blame] | 793 | EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken( |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 794 | alternative_service_info_vector[0].alternative_service())); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 795 | } |
| 796 | |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 797 | void ExpectQuicAlternateProtocolMapping() { |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 798 | const url::SchemeHostPort server(request_.url); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 799 | const AlternativeServiceInfoVector alternative_service_info_vector = |
| 800 | http_server_properties_.GetAlternativeServiceInfos(server); |
| 801 | EXPECT_EQ(1u, alternative_service_info_vector.size()); |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 802 | EXPECT_EQ( |
| 803 | kProtoQUIC, |
| 804 | alternative_service_info_vector[0].alternative_service().protocol); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 805 | EXPECT_FALSE(http_server_properties_.IsAlternativeServiceBroken( |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 806 | alternative_service_info_vector[0].alternative_service())); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 807 | } |
| 808 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 809 | void AddHangingNonAlternateProtocolSocketData() { |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 810 | std::unique_ptr<StaticSocketDataProvider> hanging_data; |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 811 | hanging_data.reset(new StaticSocketDataProvider()); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 812 | MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 813 | hanging_data->set_connect_data(hanging_connect); |
| 814 | hanging_data_.push_back(std::move(hanging_data)); |
| 815 | socket_factory_.AddSocketDataProvider(hanging_data_.back().get()); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 816 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 817 | } |
| 818 | |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 819 | void SetUpTestForRetryConnectionOnAlternateNetwork() { |
| 820 | session_params_.quic_migrate_sessions_on_network_change_v2 = true; |
| 821 | session_params_.quic_migrate_sessions_early_v2 = true; |
| 822 | session_params_.quic_retry_on_alternate_network_before_handshake = true; |
| 823 | scoped_mock_change_notifier_.reset(new ScopedMockNetworkChangeNotifier()); |
| 824 | MockNetworkChangeNotifier* mock_ncn = |
| 825 | scoped_mock_change_notifier_->mock_network_change_notifier(); |
| 826 | mock_ncn->ForceNetworkHandlesSupported(); |
| 827 | mock_ncn->SetConnectedNetworksList( |
| 828 | {kDefaultNetworkForTests, kNewNetworkForTests}); |
| 829 | } |
| 830 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 831 | // Fetches two non-cryptographic URL requests via a HTTPS proxy with a QUIC |
| 832 | // alternative proxy. Verifies that if the alternative proxy job returns |
| 833 | // |error_code|, the request is fetched successfully by the main job. |
| 834 | void TestAlternativeProxy(int error_code) { |
| 835 | // Use a non-cryptographic scheme for the request URL since this request |
| 836 | // will be fetched via proxy with QUIC as the alternative service. |
| 837 | request_.url = GURL("http://example.org/"); |
| 838 | // Data for the alternative proxy server job. |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 839 | MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, error_code, 1)}; |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 840 | MockRead quic_reads[] = { |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 841 | MockRead(SYNCHRONOUS, error_code, 0), |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 842 | }; |
| 843 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 844 | SequencedSocketData quic_data(quic_reads, quic_writes); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 845 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 846 | |
| 847 | // Main job succeeds and the alternative job fails. |
| 848 | // Add data for two requests that will be read by the main job. |
| 849 | MockRead http_reads_1[] = { |
| 850 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 851 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 852 | MockRead(ASYNC, OK)}; |
| 853 | |
| 854 | MockRead http_reads_2[] = { |
| 855 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 856 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 857 | MockRead(ASYNC, OK)}; |
| 858 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 859 | StaticSocketDataProvider http_data_1(http_reads_1, base::span<MockWrite>()); |
| 860 | StaticSocketDataProvider http_data_2(http_reads_2, base::span<MockWrite>()); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 861 | socket_factory_.AddSocketDataProvider(&http_data_1); |
| 862 | socket_factory_.AddSocketDataProvider(&http_data_2); |
| 863 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 864 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 865 | |
| 866 | TestProxyDelegate test_proxy_delegate; |
| 867 | // Proxy URL is different from the request URL. |
| 868 | test_proxy_delegate.set_alternative_proxy_server( |
| 869 | ProxyServer::FromPacString("QUIC myproxy.org:443")); |
| 870 | |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 871 | proxy_resolution_service_ = |
| 872 | ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 873 | "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 874 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 875 | |
| 876 | CreateSession(); |
| 877 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_valid()); |
| 878 | |
| 879 | // The first request should be fetched via the HTTPS proxy. |
| 880 | SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); |
| 881 | |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 882 | // Since the main job succeeded only the alternative proxy server should be |
| 883 | // marked as bad. |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 884 | EXPECT_THAT(session_->proxy_resolution_service()->proxy_retry_info(), |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 885 | ElementsAre(Key("quic://myproxy.org:443"))); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 886 | |
| 887 | // Verify that the second request completes successfully, and the |
| 888 | // alternative proxy server job is not started. |
| 889 | SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); |
| 890 | } |
| 891 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 892 | quic::QuicStreamId GetNthClientInitiatedStreamId(int n) { |
| 893 | return quic::test::GetNthClientInitiatedStreamId(version_, n); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 894 | } |
| 895 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 896 | quic::QuicStreamId GetNthServerInitiatedStreamId(int n) { |
| 897 | return quic::test::GetNthServerInitiatedStreamId(version_, n); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 898 | } |
| 899 | |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 900 | static void AddCertificate(SSLSocketDataProvider* ssl_data) { |
Ryan Sleevi | 4f83209 | 2017-11-21 23:25:49 | [diff] [blame] | 901 | ssl_data->ssl_info.cert = |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 902 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"); |
Ryan Sleevi | 4f83209 | 2017-11-21 23:25:49 | [diff] [blame] | 903 | ASSERT_TRUE(ssl_data->ssl_info.cert); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 904 | } |
| 905 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 906 | const quic::QuicTransportVersion version_; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 907 | const bool client_headers_include_h2_stream_dependency_; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 908 | quic::QuicTransportVersionVector supported_versions_; |
rch | b1c5698 | 2016-09-03 00:06:01 | [diff] [blame] | 909 | QuicFlagSaver flags_; // Save/restore all QUIC flag values. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 910 | quic::MockClock clock_; |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 911 | QuicTestPacketMaker client_maker_; |
| 912 | QuicTestPacketMaker server_maker_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 913 | std::unique_ptr<HttpNetworkSession> session_; |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 914 | MockClientSocketFactory socket_factory_; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 915 | ProofVerifyDetailsChromium verify_details_; |
[email protected] | e8ff2684 | 2013-03-22 21:02:05 | [diff] [blame] | 916 | MockCryptoClientStreamFactory crypto_client_stream_factory_; |
[email protected] | 1c04f952 | 2013-02-21 20:32:43 | [diff] [blame] | 917 | MockHostResolver host_resolver_; |
| 918 | MockCertVerifier cert_verifier_; |
[email protected] | b1c988b | 2013-06-13 06:48:11 | [diff] [blame] | 919 | TransportSecurityState transport_security_state_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 920 | std::unique_ptr<CTVerifier> cert_transparency_verifier_; |
Ryan Sleevi | 8a9c9c1 | 2018-05-09 02:36:23 | [diff] [blame] | 921 | DefaultCTPolicyEnforcer ct_policy_enforcer_; |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 922 | TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_; |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 923 | std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 924 | std::unique_ptr<ProxyResolutionService> proxy_resolution_service_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 925 | std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 926 | quic::test::MockRandom random_generator_; |
bnc | 6be245c1 | 2015-05-15 11:24:07 | [diff] [blame] | 927 | HttpServerPropertiesImpl http_server_properties_; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 928 | HttpNetworkSession::Params session_params_; |
| 929 | HttpNetworkSession::Context session_context_; |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 930 | HttpRequestInfo request_; |
vishal.b | 62985ca9 | 2015-04-17 08:45:51 | [diff] [blame] | 931 | BoundTestNetLog net_log_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 932 | std::vector<std::unique_ptr<StaticSocketDataProvider>> hanging_data_; |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 933 | SSLSocketDataProvider ssl_data_; |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 934 | std::unique_ptr<ScopedMockNetworkChangeNotifier> scoped_mock_change_notifier_; |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 935 | |
| 936 | private: |
| 937 | void SendRequestAndExpectQuicResponseMaybeFromProxy( |
| 938 | const std::string& expected, |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 939 | bool used_proxy, |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 940 | uint16_t port) { |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 941 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 942 | HeadersHandler headers_handler; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 943 | trans.SetBeforeHeadersSentCallback( |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 944 | base::Bind(&HeadersHandler::OnBeforeHeadersSent, |
| 945 | base::Unretained(&headers_handler))); |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 946 | RunTransaction(&trans); |
| 947 | CheckWasQuicResponse(&trans); |
| 948 | CheckResponsePort(&trans, port); |
| 949 | CheckResponseData(&trans, expected); |
ryansturm | 49a8cb1 | 2016-06-15 16:51:09 | [diff] [blame] | 950 | EXPECT_EQ(used_proxy, headers_handler.was_proxied()); |
tbansal | 2ecbbc7 | 2016-10-06 17:15:47 | [diff] [blame] | 951 | if (used_proxy) { |
| 952 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 953 | } else { |
| 954 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_direct()); |
| 955 | } |
tbansal | 7cec381 | 2015-02-05 21:25:12 | [diff] [blame] | 956 | } |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 957 | }; |
| 958 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 959 | INSTANTIATE_TEST_CASE_P( |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 960 | VersionIncludeStreamDependencySequence, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 961 | QuicNetworkTransactionTest, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 962 | ::testing::Combine( |
| 963 | ::testing::ValuesIn(quic::AllSupportedTransportVersions()), |
| 964 | ::testing::Bool())); |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 965 | |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 966 | TEST_P(QuicNetworkTransactionTest, WriteErrorHandshakeConfirmed) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 967 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 968 | base::HistogramTester histograms; |
| 969 | session_params_.origins_to_force_quic_on.insert( |
| 970 | HostPortPair::FromString("mail.example.org:443")); |
| 971 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 972 | MockCryptoClientStream::CONFIRM_HANDSHAKE); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 973 | |
| 974 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 975 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 976 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 977 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 978 | mock_quic_data.AddWrite(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED); |
| 979 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
| 980 | mock_quic_data.AddRead(ASYNC, OK); // No more data to read |
| 981 | |
| 982 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 983 | |
| 984 | CreateSession(); |
| 985 | |
| 986 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 987 | TestCompletionCallback callback; |
| 988 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 989 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 990 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 991 | |
| 992 | histograms.ExpectBucketCount("Net.QuicSession.WriteError", |
| 993 | -ERR_INTERNET_DISCONNECTED, 1); |
| 994 | histograms.ExpectBucketCount("Net.QuicSession.WriteError.HandshakeConfirmed", |
| 995 | -ERR_INTERNET_DISCONNECTED, 1); |
| 996 | } |
| 997 | |
| 998 | TEST_P(QuicNetworkTransactionTest, WriteErrorHandshakeConfirmedAsync) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 999 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1000 | base::HistogramTester histograms; |
| 1001 | session_params_.origins_to_force_quic_on.insert( |
| 1002 | HostPortPair::FromString("mail.example.org:443")); |
| 1003 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1004 | MockCryptoClientStream::CONFIRM_HANDSHAKE); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1005 | |
| 1006 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1007 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1008 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1009 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
Ryan Hamilton | a64a5bcf | 2017-11-30 07:35:28 | [diff] [blame] | 1010 | mock_quic_data.AddWrite(ASYNC, ERR_INTERNET_DISCONNECTED); |
| 1011 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause |
| 1012 | mock_quic_data.AddRead(ASYNC, OK); // No more data to read |
| 1013 | |
| 1014 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1015 | |
| 1016 | CreateSession(); |
| 1017 | |
| 1018 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 1019 | TestCompletionCallback callback; |
| 1020 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 1021 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1022 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 1023 | |
| 1024 | histograms.ExpectBucketCount("Net.QuicSession.WriteError", |
| 1025 | -ERR_INTERNET_DISCONNECTED, 1); |
| 1026 | histograms.ExpectBucketCount("Net.QuicSession.WriteError.HandshakeConfirmed", |
| 1027 | -ERR_INTERNET_DISCONNECTED, 1); |
| 1028 | } |
| 1029 | |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1030 | TEST_P(QuicNetworkTransactionTest, SocketWatcherEnabled) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1031 | session_params_.origins_to_force_quic_on.insert( |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1032 | HostPortPair::FromString("mail.example.org:443")); |
| 1033 | |
| 1034 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1035 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1036 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1037 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1038 | mock_quic_data.AddWrite( |
| 1039 | SYNCHRONOUS, |
| 1040 | ConstructClientRequestHeadersPacket( |
| 1041 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1042 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1043 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1044 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1045 | false, GetResponseHeaders("200 OK"))); |
| 1046 | mock_quic_data.AddRead( |
| 1047 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1048 | false, true, 0, "hello!")); |
| 1049 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1050 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 1051 | |
| 1052 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1053 | |
| 1054 | CreateSession(); |
| 1055 | test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(true); |
| 1056 | |
| 1057 | EXPECT_FALSE( |
| 1058 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1059 | SendRequestAndExpectQuicResponse("hello!"); |
| 1060 | EXPECT_TRUE( |
| 1061 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1062 | } |
| 1063 | |
| 1064 | TEST_P(QuicNetworkTransactionTest, SocketWatcherDisabled) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1065 | session_params_.origins_to_force_quic_on.insert( |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1066 | HostPortPair::FromString("mail.example.org:443")); |
| 1067 | |
| 1068 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1069 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1070 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1071 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1072 | mock_quic_data.AddWrite( |
| 1073 | SYNCHRONOUS, |
| 1074 | ConstructClientRequestHeadersPacket( |
| 1075 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1076 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1077 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1078 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1079 | false, GetResponseHeaders("200 OK"))); |
| 1080 | mock_quic_data.AddRead( |
| 1081 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1082 | false, true, 0, "hello!")); |
| 1083 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
tbansal | 180587c | 2017-02-16 15:13:23 | [diff] [blame] | 1084 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 1085 | |
| 1086 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1087 | |
| 1088 | CreateSession(); |
| 1089 | test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(false); |
| 1090 | |
| 1091 | EXPECT_FALSE( |
| 1092 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1093 | SendRequestAndExpectQuicResponse("hello!"); |
| 1094 | EXPECT_FALSE( |
| 1095 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1096 | } |
| 1097 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 1098 | TEST_P(QuicNetworkTransactionTest, ForceQuic) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1099 | session_params_.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 1100 | HostPortPair::FromString("mail.example.org:443")); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1101 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 1102 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1103 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1104 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1105 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1106 | mock_quic_data.AddWrite( |
| 1107 | SYNCHRONOUS, |
| 1108 | ConstructClientRequestHeadersPacket( |
| 1109 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1110 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1111 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1112 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1113 | false, GetResponseHeaders("200 OK"))); |
| 1114 | mock_quic_data.AddRead( |
| 1115 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1116 | false, true, 0, "hello!")); |
| 1117 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1118 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1119 | |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 1120 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1121 | |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1122 | CreateSession(); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1123 | |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 1124 | SendRequestAndExpectQuicResponse("hello!"); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1125 | |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1126 | // Check that the NetLog was filled reasonably. |
mmenke | 43758e6 | 2015-05-04 21:09:46 | [diff] [blame] | 1127 | TestNetLogEntry::List entries; |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 1128 | net_log_.GetEntries(&entries); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1129 | EXPECT_LT(0u, entries.size()); |
| 1130 | |
| 1131 | // Check that we logged a QUIC_SESSION_PACKET_RECEIVED. |
ttuttle | 859dc7a | 2015-04-23 19:42:29 | [diff] [blame] | 1132 | int pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1133 | entries, 0, NetLogEventType::QUIC_SESSION_PACKET_RECEIVED, |
| 1134 | NetLogEventPhase::NONE); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1135 | EXPECT_LT(0, pos); |
| 1136 | |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1137 | // ... and also a TYPE_QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED. |
ttuttle | 859dc7a | 2015-04-23 19:42:29 | [diff] [blame] | 1138 | pos = ExpectLogContainsSomewhere( |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1139 | entries, 0, |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1140 | NetLogEventType::QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED, |
| 1141 | NetLogEventPhase::NONE); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1142 | EXPECT_LT(0, pos); |
| 1143 | |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 1144 | std::string packet_number; |
| 1145 | ASSERT_TRUE(entries[pos].GetStringValue("packet_number", &packet_number)); |
| 1146 | EXPECT_EQ("1", packet_number); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1147 | |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1148 | // ... and also a TYPE_QUIC_SESSION_PACKET_AUTHENTICATED. |
| 1149 | pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1150 | entries, 0, NetLogEventType::QUIC_SESSION_PACKET_AUTHENTICATED, |
| 1151 | NetLogEventPhase::NONE); |
rch | fd52721 | 2015-08-25 00:41:26 | [diff] [blame] | 1152 | EXPECT_LT(0, pos); |
| 1153 | |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1154 | // ... and also a QUIC_SESSION_STREAM_FRAME_RECEIVED. |
ttuttle | 859dc7a | 2015-04-23 19:42:29 | [diff] [blame] | 1155 | pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 1156 | entries, 0, NetLogEventType::QUIC_SESSION_STREAM_FRAME_RECEIVED, |
| 1157 | NetLogEventPhase::NONE); |
[email protected] | 98b20ce | 2013-05-10 05:55:26 | [diff] [blame] | 1158 | EXPECT_LT(0, pos); |
| 1159 | |
| 1160 | int log_stream_id; |
| 1161 | ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id)); |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 1162 | EXPECT_EQ(3, log_stream_id); |
[email protected] | 4dca587c | 2013-03-07 16:54:47 | [diff] [blame] | 1163 | } |
| 1164 | |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1165 | TEST_P(QuicNetworkTransactionTest, LargeResponseHeaders) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1166 | session_params_.origins_to_force_quic_on.insert( |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1167 | HostPortPair::FromString("mail.example.org:443")); |
| 1168 | |
| 1169 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1170 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1171 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1172 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1173 | mock_quic_data.AddWrite( |
| 1174 | SYNCHRONOUS, |
| 1175 | ConstructClientRequestHeadersPacket( |
| 1176 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1177 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 1178 | spdy::SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK"); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1179 | response_headers["key1"] = std::string(30000, 'A'); |
| 1180 | response_headers["key2"] = std::string(30000, 'A'); |
| 1181 | response_headers["key3"] = std::string(30000, 'A'); |
| 1182 | response_headers["key4"] = std::string(30000, 'A'); |
| 1183 | response_headers["key5"] = std::string(30000, 'A'); |
| 1184 | response_headers["key6"] = std::string(30000, 'A'); |
| 1185 | response_headers["key7"] = std::string(30000, 'A'); |
| 1186 | response_headers["key8"] = std::string(30000, 'A'); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 1187 | spdy::SpdyHeadersIR headers_frame(GetNthClientInitiatedStreamId(0), |
| 1188 | std::move(response_headers)); |
| 1189 | spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION); |
| 1190 | spdy::SpdySerializedFrame spdy_frame = |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1191 | response_framer.SerializeFrame(headers_frame); |
| 1192 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1193 | quic::QuicPacketNumber packet_number = 1; |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1194 | size_t chunk_size = 1200; |
| 1195 | for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) { |
| 1196 | size_t len = std::min(chunk_size, spdy_frame.size() - offset); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1197 | mock_quic_data.AddRead( |
| 1198 | ASYNC, ConstructServerDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1199 | packet_number++, quic::kHeadersStreamId, false, false, |
| 1200 | offset, base::StringPiece(spdy_frame.data() + offset, len))); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1201 | } |
| 1202 | |
| 1203 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1204 | ASYNC, |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1205 | ConstructServerDataPacket(packet_number, GetNthClientInitiatedStreamId(0), |
| 1206 | false, true, 0, "hello!")); |
| 1207 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1208 | mock_quic_data.AddWrite(ASYNC, ConstructClientAckPacket(3, 2, 1, 1)); |
| 1209 | mock_quic_data.AddWrite(ASYNC, |
| 1210 | ConstructClientAckPacket(4, packet_number, 3, 1)); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1211 | |
| 1212 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1213 | |
| 1214 | CreateSession(); |
| 1215 | |
| 1216 | SendRequestAndExpectQuicResponse("hello!"); |
| 1217 | } |
| 1218 | |
| 1219 | TEST_P(QuicNetworkTransactionTest, TooLargeResponseHeaders) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 1220 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1221 | session_params_.origins_to_force_quic_on.insert( |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1222 | HostPortPair::FromString("mail.example.org:443")); |
| 1223 | |
| 1224 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1225 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1226 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1227 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1228 | mock_quic_data.AddWrite( |
| 1229 | SYNCHRONOUS, |
| 1230 | ConstructClientRequestHeadersPacket( |
| 1231 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1232 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 1233 | spdy::SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK"); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1234 | response_headers["key1"] = std::string(30000, 'A'); |
| 1235 | response_headers["key2"] = std::string(30000, 'A'); |
| 1236 | response_headers["key3"] = std::string(30000, 'A'); |
| 1237 | response_headers["key4"] = std::string(30000, 'A'); |
| 1238 | response_headers["key5"] = std::string(30000, 'A'); |
| 1239 | response_headers["key6"] = std::string(30000, 'A'); |
| 1240 | response_headers["key7"] = std::string(30000, 'A'); |
| 1241 | response_headers["key8"] = std::string(30000, 'A'); |
| 1242 | response_headers["key9"] = std::string(30000, 'A'); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 1243 | spdy::SpdyHeadersIR headers_frame(GetNthClientInitiatedStreamId(0), |
| 1244 | std::move(response_headers)); |
| 1245 | spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION); |
| 1246 | spdy::SpdySerializedFrame spdy_frame = |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1247 | response_framer.SerializeFrame(headers_frame); |
| 1248 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1249 | quic::QuicPacketNumber packet_number = 1; |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1250 | size_t chunk_size = 1200; |
| 1251 | for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) { |
| 1252 | size_t len = std::min(chunk_size, spdy_frame.size() - offset); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1253 | mock_quic_data.AddRead( |
| 1254 | ASYNC, ConstructServerDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1255 | packet_number++, quic::kHeadersStreamId, false, false, |
| 1256 | offset, base::StringPiece(spdy_frame.data() + offset, len))); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1257 | } |
| 1258 | |
| 1259 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1260 | ASYNC, |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1261 | ConstructServerDataPacket(packet_number, GetNthClientInitiatedStreamId(0), |
| 1262 | false, true, 0, "hello!")); |
| 1263 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1264 | mock_quic_data.AddWrite(ASYNC, ConstructClientAckPacket(3, 2, 1, 1)); |
| 1265 | mock_quic_data.AddWrite( |
| 1266 | ASYNC, ConstructClientAckAndRstPacket(4, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1267 | quic::QUIC_HEADERS_TOO_LARGE, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1268 | packet_number, 3, 1)); |
rch | bd089ab | 2017-05-26 23:05:04 | [diff] [blame] | 1269 | |
| 1270 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1271 | |
| 1272 | CreateSession(); |
| 1273 | |
| 1274 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 1275 | TestCompletionCallback callback; |
| 1276 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 1277 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1278 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 1279 | } |
| 1280 | |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1281 | TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1282 | session_params_.origins_to_force_quic_on.insert(HostPortPair()); |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1283 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1284 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1285 | |
| 1286 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1287 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1288 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1289 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1290 | mock_quic_data.AddWrite( |
| 1291 | SYNCHRONOUS, |
| 1292 | ConstructClientRequestHeadersPacket( |
| 1293 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1294 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1295 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1296 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1297 | false, GetResponseHeaders("200 OK"))); |
| 1298 | mock_quic_data.AddRead( |
| 1299 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1300 | false, true, 0, "hello!")); |
| 1301 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | a2bd44b | 2016-07-02 00:42:55 | [diff] [blame] | 1302 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 1303 | |
| 1304 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1305 | |
| 1306 | CreateSession(); |
| 1307 | |
| 1308 | SendRequestAndExpectQuicResponse("hello!"); |
| 1309 | EXPECT_TRUE( |
| 1310 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
| 1311 | } |
| 1312 | |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1313 | TEST_P(QuicNetworkTransactionTest, QuicProxy) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1314 | session_params_.enable_quic = true; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 1315 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 1316 | "QUIC mail.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1317 | |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1318 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1319 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1320 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1321 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1322 | mock_quic_data.AddWrite( |
| 1323 | SYNCHRONOUS, |
| 1324 | ConstructClientRequestHeadersPacket( |
| 1325 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1326 | GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
| 1327 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1328 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1329 | false, GetResponseHeaders("200 OK"))); |
| 1330 | mock_quic_data.AddRead( |
| 1331 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1332 | false, true, 0, "hello!")); |
| 1333 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 1334 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1335 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1336 | |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 1337 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1338 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1339 | EXPECT_FALSE( |
| 1340 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1341 | // There is no need to set up an alternate protocol job, because |
| 1342 | // no attempt will be made to speak to the proxy over TCP. |
| 1343 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 1344 | request_.url = GURL("http://mail.example.org/"); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1345 | CreateSession(); |
| 1346 | |
bnc | 62a44f02 | 2015-04-02 15:59:41 | [diff] [blame] | 1347 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1348 | EXPECT_TRUE( |
| 1349 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
[email protected] | cf3e3cd6 | 2014-02-05 16:16:16 | [diff] [blame] | 1350 | } |
| 1351 | |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1352 | // Regression test for https://crbug.com/492458. Test that for an HTTP |
| 1353 | // connection through a QUIC proxy, the certificate exhibited by the proxy is |
| 1354 | // checked against the proxy hostname, not the origin hostname. |
| 1355 | TEST_P(QuicNetworkTransactionTest, QuicProxyWithCert) { |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 1356 | const std::string origin_host = "mail.example.com"; |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1357 | const std::string proxy_host = "www.example.org"; |
| 1358 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1359 | session_params_.enable_quic = true; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 1360 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 1361 | "QUIC " + proxy_host + ":70", TRAFFIC_ANNOTATION_FOR_TESTS); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1362 | |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 1363 | client_maker_.set_hostname(origin_host); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1364 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1365 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1366 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1367 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1368 | mock_quic_data.AddWrite( |
| 1369 | SYNCHRONOUS, |
| 1370 | ConstructClientRequestHeadersPacket( |
| 1371 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1372 | GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
| 1373 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1374 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1375 | false, GetResponseHeaders("200 OK"))); |
| 1376 | mock_quic_data.AddRead( |
| 1377 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1378 | false, true, 0, "hello!")); |
| 1379 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 1380 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1381 | mock_quic_data.AddRead(ASYNC, 0); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1382 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1383 | |
| 1384 | scoped_refptr<X509Certificate> cert( |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 1385 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1386 | ASSERT_TRUE(cert.get()); |
| 1387 | // This certificate is valid for the proxy, but not for the origin. |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 1388 | EXPECT_TRUE(cert->VerifyNameMatch(proxy_host)); |
| 1389 | EXPECT_FALSE(cert->VerifyNameMatch(origin_host)); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1390 | ProofVerifyDetailsChromium verify_details; |
| 1391 | verify_details.cert_verify_result.verified_cert = cert; |
| 1392 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 1393 | ProofVerifyDetailsChromium verify_details2; |
| 1394 | verify_details2.cert_verify_result.verified_cert = cert; |
| 1395 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1396 | |
| 1397 | request_.url = GURL("http://" + origin_host); |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 1398 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 1399 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1400 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
bnc | 313ba9c | 2015-06-11 15:42:31 | [diff] [blame] | 1401 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70); |
| 1402 | } |
| 1403 | |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1404 | TEST_P(QuicNetworkTransactionTest, AlternativeServicesDifferentHost) { |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 1405 | session_params_.quic_allow_remote_alt_svc = true; |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1406 | HostPortPair origin("www.example.org", 443); |
| 1407 | HostPortPair alternative("mail.example.org", 443); |
| 1408 | |
| 1409 | base::FilePath certs_dir = GetTestCertsDirectory(); |
| 1410 | scoped_refptr<X509Certificate> cert( |
| 1411 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
| 1412 | ASSERT_TRUE(cert.get()); |
| 1413 | // TODO(rch): the connection should be "to" the origin, so if the cert is |
| 1414 | // valid for the origin but not the alternative, that should work too. |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 1415 | EXPECT_TRUE(cert->VerifyNameMatch(origin.host())); |
| 1416 | EXPECT_TRUE(cert->VerifyNameMatch(alternative.host())); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1417 | ProofVerifyDetailsChromium verify_details; |
| 1418 | verify_details.cert_verify_result.verified_cert = cert; |
| 1419 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 1420 | |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 1421 | client_maker_.set_hostname(origin.host()); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1422 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1423 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1424 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1425 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1426 | mock_quic_data.AddWrite( |
| 1427 | SYNCHRONOUS, |
| 1428 | ConstructClientRequestHeadersPacket( |
| 1429 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1430 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1431 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1432 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1433 | false, GetResponseHeaders("200 OK"))); |
| 1434 | mock_quic_data.AddRead( |
| 1435 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1436 | false, true, 0, "hello!")); |
| 1437 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1438 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1439 | mock_quic_data.AddRead(ASYNC, 0); |
| 1440 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1441 | |
| 1442 | request_.url = GURL("https://" + origin.host()); |
| 1443 | AddQuicRemoteAlternativeServiceMapping( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 1444 | MockCryptoClientStream::CONFIRM_HANDSHAKE, alternative); |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 1445 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 1446 | CreateSession(); |
rch | be69cb90 | 2016-02-11 01:10:48 | [diff] [blame] | 1447 | |
| 1448 | SendRequestAndExpectQuicResponse("hello!"); |
| 1449 | } |
| 1450 | |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1451 | TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) { |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1452 | quic::QuicTransportVersion unsupported_version = |
| 1453 | quic::QUIC_VERSION_UNSUPPORTED; |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1454 | // Add support for another QUIC version besides |version_|. Also find a |
| 1455 | // unsupported version. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1456 | for (const quic::QuicTransportVersion& version : |
| 1457 | quic::AllSupportedTransportVersions()) { |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1458 | if (version == version_) |
| 1459 | continue; |
| 1460 | if (supported_versions_.size() != 2) { |
| 1461 | supported_versions_.push_back(version); |
| 1462 | continue; |
| 1463 | } |
| 1464 | unsupported_version = version; |
| 1465 | break; |
| 1466 | } |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1467 | DCHECK_NE(unsupported_version, quic::QUIC_VERSION_UNSUPPORTED); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1468 | |
| 1469 | // Set up alternative service to use QUIC with a version that is not |
| 1470 | // supported. |
| 1471 | url::SchemeHostPort server(request_.url); |
| 1472 | AlternativeService alternative_service(kProtoQUIC, kDefaultServerHostName, |
| 1473 | 443); |
| 1474 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| 1475 | http_server_properties_.SetQuicAlternativeService( |
| 1476 | server, alternative_service, expiration, {unsupported_version}); |
| 1477 | |
| 1478 | AlternativeServiceInfoVector alt_svc_info_vector = |
| 1479 | http_server_properties_.GetAlternativeServiceInfos(server); |
| 1480 | EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| 1481 | EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| 1482 | EXPECT_EQ(1u, alt_svc_info_vector[0].advertised_versions().size()); |
| 1483 | EXPECT_EQ(unsupported_version, |
| 1484 | alt_svc_info_vector[0].advertised_versions()[0]); |
| 1485 | |
| 1486 | // First request should still be sent via TCP as the QUIC version advertised |
| 1487 | // in the stored AlternativeService is not supported by the client. However, |
| 1488 | // the response from the server will advertise new Alt-Svc with supported |
| 1489 | // versions. |
| 1490 | std::string advertised_versions_list_str = |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1491 | GenerateQuicVersionsListForAltSvcHeader( |
| 1492 | quic::AllSupportedTransportVersions()); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1493 | std::string altsvc_header = |
| 1494 | base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n", |
| 1495 | advertised_versions_list_str.c_str()); |
| 1496 | MockRead http_reads[] = { |
| 1497 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 1498 | MockRead("hello world"), |
| 1499 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1500 | MockRead(ASYNC, OK)}; |
| 1501 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1502 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1503 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1504 | AddCertificate(&ssl_data_); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1505 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1506 | |
| 1507 | // Second request should be sent via QUIC as a new list of verions supported |
| 1508 | // by the client has been advertised by the server. |
| 1509 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1510 | quic::QuicStreamOffset header_stream_offset = 0; |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1511 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1512 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1513 | mock_quic_data.AddWrite( |
| 1514 | SYNCHRONOUS, |
| 1515 | ConstructClientRequestHeadersPacket( |
| 1516 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1517 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1518 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1519 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1520 | false, GetResponseHeaders("200 OK"))); |
| 1521 | mock_quic_data.AddRead( |
| 1522 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1523 | false, true, 0, "hello!")); |
| 1524 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
zhongyi | ef3f4ce5 | 2017-07-05 23:53:28 | [diff] [blame] | 1525 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1526 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 1527 | |
| 1528 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1529 | |
| 1530 | AddHangingNonAlternateProtocolSocketData(); |
| 1531 | |
| 1532 | CreateSession(supported_versions_); |
| 1533 | |
| 1534 | SendRequestAndExpectHttpResponse("hello world"); |
| 1535 | SendRequestAndExpectQuicResponse("hello!"); |
| 1536 | |
| 1537 | // Check alternative service list is updated with new versions. |
| 1538 | alt_svc_info_vector = |
| 1539 | session_->http_server_properties()->GetAlternativeServiceInfos(server); |
| 1540 | EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| 1541 | EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| 1542 | EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size()); |
| 1543 | // Advertised versions will be lised in a sorted order. |
| 1544 | std::sort(supported_versions_.begin(), supported_versions_.end()); |
| 1545 | EXPECT_EQ(supported_versions_[0], |
| 1546 | alt_svc_info_vector[0].advertised_versions()[0]); |
| 1547 | EXPECT_EQ(supported_versions_[1], |
| 1548 | alt_svc_info_vector[0].advertised_versions()[1]); |
| 1549 | } |
| 1550 | |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1551 | // Regression test for https://crbug.com/546991. |
| 1552 | // The server might not be able to serve a request on an alternative connection, |
| 1553 | // and might send a 421 Misdirected Request response status to indicate this. |
| 1554 | // HttpNetworkTransaction should reset the request and retry without using |
| 1555 | // alternative services. |
| 1556 | TEST_P(QuicNetworkTransactionTest, RetryMisdirectedRequest) { |
| 1557 | // Set up alternative service to use QUIC. |
| 1558 | // Note that |origins_to_force_quic_on| cannot be used in this test, because |
| 1559 | // that overrides |enable_alternative_services|. |
| 1560 | url::SchemeHostPort server(request_.url); |
| 1561 | AlternativeService alternative_service(kProtoQUIC, kDefaultServerHostName, |
| 1562 | 443); |
| 1563 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 1564 | http_server_properties_.SetQuicAlternativeService( |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 1565 | server, alternative_service, expiration, supported_versions_); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1566 | |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1567 | // First try: The alternative job uses QUIC and reports an HTTP 421 |
| 1568 | // Misdirected Request error. The main job uses TCP, but |http_data| below is |
| 1569 | // paused at Connect(), so it will never exit the socket pool. This ensures |
| 1570 | // that the alternate job always wins the race and keeps whether the |
| 1571 | // |http_data| exits the socket pool before the main job is aborted |
| 1572 | // deterministic. The first main job gets aborted without the socket pool ever |
| 1573 | // dispensing the socket, making it available for the second try. |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1574 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1575 | quic::QuicStreamOffset request_header_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1576 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1577 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
| 1578 | mock_quic_data.AddWrite( |
| 1579 | SYNCHRONOUS, |
| 1580 | ConstructClientRequestHeadersPacket( |
| 1581 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1582 | GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
| 1583 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1584 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1585 | true, GetResponseHeaders("421"), nullptr)); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1586 | mock_quic_data.AddRead(ASYNC, OK); |
| 1587 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1588 | |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1589 | // Second try: The main job uses TCP, and there is no alternate job. Once the |
| 1590 | // Connect() is unblocked, |http_data| will leave the socket pool, binding to |
| 1591 | // the main job of the second request. It then succeeds over HTTP/1.1. |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1592 | // Note that if there was an alternative QUIC Job created for the second try, |
| 1593 | // that would read these data, and would fail with ERR_QUIC_PROTOCOL_ERROR. |
| 1594 | // Therefore this test ensures that no alternative Job is created on retry. |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1595 | MockWrite writes[] = {MockWrite(ASYNC, 0, "GET / HTTP/1.1\r\n"), |
| 1596 | MockWrite(ASYNC, 1, "Host: mail.example.org\r\n"), |
| 1597 | MockWrite(ASYNC, 2, "Connection: keep-alive\r\n\r\n")}; |
| 1598 | MockRead reads[] = {MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n\r\n"), |
| 1599 | MockRead(ASYNC, 4, "hello!"), MockRead(ASYNC, OK, 5)}; |
| 1600 | SequencedSocketData http_data(MockConnect(ASYNC, ERR_IO_PENDING) /* pause */, |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1601 | reads, writes); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1602 | socket_factory_.AddSocketDataProvider(&http_data); |
| 1603 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1604 | |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1605 | CreateSession(); |
| 1606 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
davidben | a444972 | 2017-05-05 23:30:53 | [diff] [blame] | 1607 | |
| 1608 | // Run until |mock_quic_data| has failed and |http_data| has paused. |
| 1609 | TestCompletionCallback callback; |
| 1610 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 1611 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1612 | base::RunLoop().RunUntilIdle(); |
| 1613 | |
| 1614 | // |mock_quic_data| must have run to completion. |
| 1615 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 1616 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 1617 | |
| 1618 | // Now that the QUIC data has been consumed, unblock |http_data|. |
| 1619 | http_data.socket()->OnConnectComplete(MockConnect()); |
| 1620 | |
| 1621 | // The retry logic must hide the 421 status. The transaction succeeds on |
| 1622 | // |http_data|. |
| 1623 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
bnc | accd496 | 2017-04-06 21:00:26 | [diff] [blame] | 1624 | CheckWasHttpResponse(&trans); |
| 1625 | CheckResponsePort(&trans, 443); |
| 1626 | CheckResponseData(&trans, "hello!"); |
| 1627 | } |
| 1628 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 1629 | TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1630 | session_params_.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 1631 | HostPortPair::FromString("mail.example.org:443")); |
[email protected] | cebe328 | 2013-05-22 23:49:30 | [diff] [blame] | 1632 | |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1633 | MockQuicData mock_quic_data1; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1634 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1635 | mock_quic_data1.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1636 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1637 | mock_quic_data1.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1638 | MockQuicData mock_quic_data2; |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 1639 | header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1640 | mock_quic_data2.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1641 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 1642 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1643 | mock_quic_data2.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED); |
rch | 6faa4d4 | 2016-01-05 20:48:43 | [diff] [blame] | 1644 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1645 | |
| 1646 | mock_quic_data1.AddSocketDataToFactory(&socket_factory_); |
| 1647 | mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
[email protected] | cebe328 | 2013-05-22 23:49:30 | [diff] [blame] | 1648 | |
| 1649 | CreateSession(); |
| 1650 | |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1651 | EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count()); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1652 | for (size_t i = 0; i < 2; ++i) { |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 1653 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1654 | TestCompletionCallback callback; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 1655 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 1656 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 1657 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED)); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1658 | EXPECT_EQ(1 + i, test_socket_performance_watcher_factory_.watcher_count()); |
Ryan Hamilton | e316e48 | 2017-08-17 02:48:53 | [diff] [blame] | 1659 | |
| 1660 | NetErrorDetails details; |
| 1661 | trans.PopulateNetErrorDetails(&details); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1662 | EXPECT_EQ(quic::QUIC_PACKET_READ_ERROR, details.quic_connection_error); |
tbansal | fdf5665b | 2015-09-21 22:46:40 | [diff] [blame] | 1663 | } |
[email protected] | cebe328 | 2013-05-22 23:49:30 | [diff] [blame] | 1664 | } |
| 1665 | |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1666 | TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) { |
| 1667 | // Attempt to "force" quic on 443, which will not be honored. |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 1668 | session_params_.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 1669 | HostPortPair::FromString("www.google.com:443")); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1670 | |
| 1671 | MockRead http_reads[] = { |
| 1672 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"), |
| 1673 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1674 | MockRead(ASYNC, OK)}; |
| 1675 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1676 | StaticSocketDataProvider data(http_reads, base::span<MockWrite>()); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1677 | socket_factory_.AddSocketDataProvider(&data); |
| 1678 | SSLSocketDataProvider ssl(ASYNC, OK); |
| 1679 | socket_factory_.AddSSLSocketDataProvider(&ssl); |
| 1680 | |
| 1681 | CreateSession(); |
| 1682 | |
| 1683 | SendRequestAndExpectHttpResponse("hello world"); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 1684 | EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count()); |
tbansal | c8a94ea | 2015-11-02 23:58:51 | [diff] [blame] | 1685 | } |
| 1686 | |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1687 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuic) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1688 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 1689 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 1690 | MockRead("hello world"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1691 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1692 | MockRead(ASYNC, OK)}; |
| 1693 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1694 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1695 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1696 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 1697 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1698 | |
| 1699 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1700 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1701 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1702 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1703 | mock_quic_data.AddWrite( |
| 1704 | SYNCHRONOUS, |
| 1705 | ConstructClientRequestHeadersPacket( |
| 1706 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1707 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1708 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1709 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1710 | false, GetResponseHeaders("200 OK"))); |
| 1711 | mock_quic_data.AddRead( |
| 1712 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1713 | false, true, 0, "hello!")); |
| 1714 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1715 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 1716 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1717 | |
| 1718 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1719 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 1720 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 1721 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 1722 | |
| 1723 | SendRequestAndExpectHttpResponse("hello world"); |
| 1724 | SendRequestAndExpectQuicResponse("hello!"); |
| 1725 | } |
| 1726 | |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1727 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic1) { |
| 1728 | // Both server advertises and client supports two QUIC versions. |
| 1729 | // Only |version_| is advertised and supported. |
| 1730 | // The QuicStreamFactoy will pick up |version_|, which is verified as the |
| 1731 | // PacketMakers are using |version_|. |
| 1732 | |
| 1733 | // Add support for another QUIC version besides |version_| on the client side. |
| 1734 | // Also find a different version advertised by the server. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1735 | quic::QuicTransportVersion advertised_version_2 = |
| 1736 | quic::QUIC_VERSION_UNSUPPORTED; |
| 1737 | for (const quic::QuicTransportVersion& version : |
| 1738 | quic::AllSupportedTransportVersions()) { |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1739 | if (version == version_) |
| 1740 | continue; |
| 1741 | if (supported_versions_.size() != 2) { |
| 1742 | supported_versions_.push_back(version); |
| 1743 | continue; |
| 1744 | } |
| 1745 | advertised_version_2 = version; |
| 1746 | break; |
| 1747 | } |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1748 | DCHECK_NE(advertised_version_2, quic::QUIC_VERSION_UNSUPPORTED); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1749 | |
| 1750 | std::string QuicAltSvcWithVersionHeader = |
| 1751 | base::StringPrintf("Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n", |
| 1752 | advertised_version_2, version_); |
| 1753 | |
| 1754 | MockRead http_reads[] = { |
| 1755 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 1756 | MockRead(QuicAltSvcWithVersionHeader.c_str()), MockRead("hello world"), |
| 1757 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1758 | MockRead(ASYNC, OK)}; |
| 1759 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1760 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1761 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1762 | AddCertificate(&ssl_data_); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1763 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1764 | |
| 1765 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1766 | quic::QuicStreamOffset header_stream_offset = 0; |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1767 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1768 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1769 | mock_quic_data.AddWrite( |
| 1770 | SYNCHRONOUS, |
| 1771 | ConstructClientRequestHeadersPacket( |
| 1772 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1773 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1774 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1775 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1776 | false, GetResponseHeaders("200 OK"))); |
| 1777 | mock_quic_data.AddRead( |
| 1778 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1779 | false, true, 0, "hello!")); |
| 1780 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1781 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1782 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 1783 | |
| 1784 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1785 | |
| 1786 | AddHangingNonAlternateProtocolSocketData(); |
| 1787 | CreateSession(supported_versions_); |
| 1788 | |
| 1789 | SendRequestAndExpectHttpResponse("hello world"); |
| 1790 | SendRequestAndExpectQuicResponse("hello!"); |
| 1791 | } |
| 1792 | |
| 1793 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic2) { |
| 1794 | // Client and server mutually support more than one QUIC_VERSION. |
| 1795 | // The QuicStreamFactoy will pick the preferred QUIC_VERSION: |version_|, |
| 1796 | // which is verified as the PacketMakers are using |version_|. |
| 1797 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1798 | quic::QuicTransportVersion common_version_2 = quic::QUIC_VERSION_UNSUPPORTED; |
| 1799 | for (const quic::QuicTransportVersion& version : |
| 1800 | quic::AllSupportedTransportVersions()) { |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1801 | if (version == version_) |
| 1802 | continue; |
| 1803 | common_version_2 = version; |
| 1804 | break; |
| 1805 | } |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1806 | DCHECK_NE(common_version_2, quic::QUIC_VERSION_UNSUPPORTED); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1807 | |
| 1808 | supported_versions_.push_back( |
| 1809 | common_version_2); // Supported but unpreferred. |
| 1810 | |
| 1811 | std::string QuicAltSvcWithVersionHeader = base::StringPrintf( |
| 1812 | "Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n", common_version_2, version_); |
| 1813 | |
| 1814 | MockRead http_reads[] = { |
| 1815 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 1816 | MockRead(QuicAltSvcWithVersionHeader.c_str()), MockRead("hello world"), |
| 1817 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1818 | MockRead(ASYNC, OK)}; |
| 1819 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1820 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1821 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1822 | AddCertificate(&ssl_data_); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1823 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1824 | |
| 1825 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1826 | quic::QuicStreamOffset header_stream_offset = 0; |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1827 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1828 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1829 | mock_quic_data.AddWrite( |
| 1830 | SYNCHRONOUS, |
| 1831 | ConstructClientRequestHeadersPacket( |
| 1832 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1833 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1834 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1835 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1836 | false, GetResponseHeaders("200 OK"))); |
| 1837 | mock_quic_data.AddRead( |
| 1838 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1839 | false, true, 0, "hello!")); |
| 1840 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
zhongyi | a00ca01 | 2017-07-06 23:36:39 | [diff] [blame] | 1841 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1842 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 1843 | |
| 1844 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1845 | |
| 1846 | AddHangingNonAlternateProtocolSocketData(); |
| 1847 | CreateSession(supported_versions_); |
| 1848 | |
| 1849 | SendRequestAndExpectHttpResponse("hello world"); |
| 1850 | SendRequestAndExpectQuicResponse("hello!"); |
| 1851 | } |
| 1852 | |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 1853 | TEST_P(QuicNetworkTransactionTest, |
| 1854 | UseAlternativeServiceWithProbabilityForQuic) { |
| 1855 | MockRead http_reads[] = { |
| 1856 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 1857 | MockRead(kQuicAlternativeServiceWithProbabilityHeader), |
| 1858 | MockRead("hello world"), |
| 1859 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1860 | MockRead(ASYNC, OK)}; |
| 1861 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1862 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 1863 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1864 | AddCertificate(&ssl_data_); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 1865 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1866 | |
| 1867 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1868 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 1869 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1870 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1871 | mock_quic_data.AddWrite( |
| 1872 | SYNCHRONOUS, |
| 1873 | ConstructClientRequestHeadersPacket( |
| 1874 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1875 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1876 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1877 | 1, GetNthClientInitiatedStreamId(0), false, |
| 1878 | false, GetResponseHeaders("200 OK"))); |
| 1879 | mock_quic_data.AddRead( |
| 1880 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 1881 | false, true, 0, "hello!")); |
| 1882 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 1883 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 1884 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 1885 | |
| 1886 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 1887 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 1888 | AddHangingNonAlternateProtocolSocketData(); |
rch | f47265dc | 2016-03-21 21:33:12 | [diff] [blame] | 1889 | CreateSession(); |
| 1890 | |
| 1891 | SendRequestAndExpectHttpResponse("hello world"); |
| 1892 | SendRequestAndExpectQuicResponse("hello!"); |
| 1893 | } |
| 1894 | |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1895 | TEST_P(QuicNetworkTransactionTest, SetAlternativeServiceWithScheme) { |
| 1896 | MockRead http_reads[] = { |
| 1897 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 1898 | MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
| 1899 | MockRead("hello world"), |
| 1900 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1901 | MockRead(ASYNC, OK)}; |
| 1902 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1903 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1904 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1905 | AddCertificate(&ssl_data_); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1906 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1907 | |
| 1908 | CreateSession(); |
bnc | b2602438 | 2016-06-29 02:39:45 | [diff] [blame] | 1909 | // Send https request, ignore alternative service advertising if response |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1910 | // header advertises alternative service for mail.example.org. |
bnc | b2602438 | 2016-06-29 02:39:45 | [diff] [blame] | 1911 | request_.url = GURL("https://mail.example.org:443"); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1912 | SendRequestAndExpectHttpResponse("hello world"); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 1913 | HttpServerProperties* http_server_properties = |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1914 | session_->http_server_properties(); |
| 1915 | url::SchemeHostPort http_server("http", "mail.example.org", 443); |
| 1916 | url::SchemeHostPort https_server("https", "mail.example.org", 443); |
| 1917 | // Check alternative service is set for the correct origin. |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1918 | EXPECT_EQ( |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 1919 | 2u, |
| 1920 | http_server_properties->GetAlternativeServiceInfos(https_server).size()); |
bnc | b2602438 | 2016-06-29 02:39:45 | [diff] [blame] | 1921 | EXPECT_TRUE( |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 1922 | http_server_properties->GetAlternativeServiceInfos(http_server).empty()); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1923 | } |
| 1924 | |
| 1925 | TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) { |
| 1926 | MockRead http_reads[] = { |
| 1927 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 1928 | MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
| 1929 | MockRead("hello world"), |
| 1930 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1931 | MockRead(ASYNC, OK)}; |
| 1932 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1933 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1934 | AddCertificate(&ssl_data_); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1935 | |
| 1936 | socket_factory_.AddSocketDataProvider(&http_data); |
| 1937 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1938 | socket_factory_.AddSocketDataProvider(&http_data); |
| 1939 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1940 | |
| 1941 | CreateSession(); |
| 1942 | |
| 1943 | // Send https request and set alternative services if response header |
| 1944 | // advertises alternative service for mail.example.org. |
| 1945 | SendRequestAndExpectHttpResponse("hello world"); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 1946 | HttpServerProperties* http_server_properties = |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1947 | session_->http_server_properties(); |
| 1948 | |
| 1949 | const url::SchemeHostPort https_server(request_.url); |
| 1950 | // Check alternative service is set. |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 1951 | EXPECT_EQ( |
| 1952 | 2u, |
| 1953 | http_server_properties->GetAlternativeServiceInfos(https_server).size()); |
zhongyi | 3d4a55e7 | 2016-04-22 20:36:46 | [diff] [blame] | 1954 | |
| 1955 | // Send http request to the same origin but with diffrent scheme, should not |
| 1956 | // use QUIC. |
| 1957 | request_.url = GURL("http://mail.example.org:443"); |
| 1958 | SendRequestAndExpectHttpResponse("hello world"); |
| 1959 | } |
| 1960 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 1961 | TEST_P(QuicNetworkTransactionTest, |
| 1962 | StoreMutuallySupportedVersionsWhenProcessAltSvc) { |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 1963 | // Add support for another QUIC version besides |version_|. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1964 | for (const quic::QuicTransportVersion& version : |
| 1965 | quic::AllSupportedTransportVersions()) { |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 1966 | if (version == version_) |
| 1967 | continue; |
| 1968 | supported_versions_.push_back(version); |
| 1969 | break; |
| 1970 | } |
| 1971 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 1972 | std::string advertised_versions_list_str = |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1973 | GenerateQuicVersionsListForAltSvcHeader( |
| 1974 | quic::AllSupportedTransportVersions()); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 1975 | std::string altsvc_header = |
| 1976 | base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n", |
| 1977 | advertised_versions_list_str.c_str()); |
| 1978 | MockRead http_reads[] = { |
| 1979 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 1980 | MockRead("hello world"), |
| 1981 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 1982 | MockRead(ASYNC, OK)}; |
| 1983 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 1984 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 1985 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 1986 | AddCertificate(&ssl_data_); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 1987 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 1988 | |
| 1989 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 1990 | quic::QuicStreamOffset header_stream_offset = 0; |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 1991 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 1992 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 1993 | mock_quic_data.AddWrite( |
| 1994 | SYNCHRONOUS, |
| 1995 | ConstructClientRequestHeadersPacket( |
| 1996 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 1997 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 1998 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 1999 | 1, GetNthClientInitiatedStreamId(0), false, |
| 2000 | false, GetResponseHeaders("200 OK"))); |
| 2001 | mock_quic_data.AddRead( |
| 2002 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 2003 | false, true, 0, "hello!")); |
| 2004 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2005 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 2006 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 2007 | |
| 2008 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2009 | |
| 2010 | AddHangingNonAlternateProtocolSocketData(); |
| 2011 | |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2012 | CreateSession(supported_versions_); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2013 | |
| 2014 | SendRequestAndExpectHttpResponse("hello world"); |
| 2015 | SendRequestAndExpectQuicResponse("hello!"); |
| 2016 | |
| 2017 | // Check alternative service is set with only mutually supported versions. |
| 2018 | const url::SchemeHostPort https_server(request_.url); |
| 2019 | const AlternativeServiceInfoVector alt_svc_info_vector = |
| 2020 | session_->http_server_properties()->GetAlternativeServiceInfos( |
| 2021 | https_server); |
| 2022 | EXPECT_EQ(1u, alt_svc_info_vector.size()); |
| 2023 | EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); |
| 2024 | EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size()); |
| 2025 | // Advertised versions will be lised in a sorted order. |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2026 | std::sort(supported_versions_.begin(), supported_versions_.end()); |
| 2027 | EXPECT_EQ(supported_versions_[0], |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2028 | alt_svc_info_vector[0].advertised_versions()[0]); |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 2029 | EXPECT_EQ(supported_versions_[1], |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 2030 | alt_svc_info_vector[0].advertised_versions()[1]); |
| 2031 | } |
| 2032 | |
danzh | 3134c256 | 2016-08-12 14:07:52 | [diff] [blame] | 2033 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceAllSupportedVersion) { |
bnc | 90be5dd78 | 2016-11-09 16:28:44 | [diff] [blame] | 2034 | std::string altsvc_header = |
| 2035 | base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2036 | MockRead http_reads[] = { |
| 2037 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 2038 | MockRead("hello world"), |
| 2039 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 2040 | MockRead(ASYNC, OK)}; |
| 2041 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 2042 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2043 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 2044 | AddCertificate(&ssl_data_); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2045 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2046 | |
| 2047 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2048 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 2049 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2050 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 2051 | mock_quic_data.AddWrite( |
| 2052 | SYNCHRONOUS, |
| 2053 | ConstructClientRequestHeadersPacket( |
| 2054 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 2055 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 2056 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 2057 | 1, GetNthClientInitiatedStreamId(0), false, |
| 2058 | false, GetResponseHeaders("200 OK"))); |
| 2059 | mock_quic_data.AddRead( |
| 2060 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 2061 | false, true, 0, "hello!")); |
| 2062 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2063 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 2064 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2065 | |
| 2066 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2067 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 2068 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 2069 | CreateSession(); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 2070 | |
| 2071 | SendRequestAndExpectHttpResponse("hello world"); |
| 2072 | SendRequestAndExpectQuicResponse("hello!"); |
| 2073 | } |
| 2074 | |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2075 | TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) { |
Frank Kastenholz | 6e4c538 | 2018-06-21 23:00:09 | [diff] [blame] | 2076 | if (version_ == quic::QUIC_VERSION_99) { |
| 2077 | // Not available under version 99 |
| 2078 | return; |
| 2079 | } |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2080 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2081 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 2082 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2083 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 2084 | mock_quic_data.AddWrite( |
| 2085 | SYNCHRONOUS, |
| 2086 | ConstructClientRequestHeadersPacket( |
| 2087 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 2088 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 2089 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 2090 | 1, GetNthClientInitiatedStreamId(0), false, |
| 2091 | false, GetResponseHeaders("200 OK"))); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2092 | // Read a GoAway packet with |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2093 | // quic::QuicErrorCode: quic::QUIC_ERROR_MIGRATING_PORT from the peer. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2094 | mock_quic_data.AddRead(SYNCHRONOUS, |
| 2095 | ConstructServerGoAwayPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2096 | 2, quic::QUIC_ERROR_MIGRATING_PORT, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2097 | "connection migration with port change only")); |
| 2098 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| 2099 | mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerDataPacket( |
| 2100 | 3, GetNthClientInitiatedStreamId(0), |
| 2101 | false, true, 0, "hello!")); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2102 | mock_quic_data.AddWrite( |
| 2103 | SYNCHRONOUS, |
| 2104 | ConstructClientAckAndRstPacket(4, GetNthClientInitiatedStreamId(0), |
| 2105 | quic::QUIC_STREAM_CANCELLED, 3, 3, 1)); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2106 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 2107 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 2108 | |
| 2109 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2110 | |
| 2111 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 2112 | // the alternate-protocol job will "win". |
| 2113 | AddHangingNonAlternateProtocolSocketData(); |
| 2114 | |
| 2115 | // In order for a new QUIC session to be established via alternate-protocol |
| 2116 | // without racing an HTTP connection, we need the host resolution to happen |
| 2117 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2118 | // connection to the the server, in this test we require confirmation |
| 2119 | // before encrypting so the HTTP job will still start. |
| 2120 | host_resolver_.set_synchronous_mode(true); |
| 2121 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2122 | ""); |
| 2123 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2124 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 2125 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 2126 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2127 | CompletionOnceCallback(), &request, |
| 2128 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2129 | EXPECT_THAT(rv, IsOk()); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2130 | |
| 2131 | CreateSession(); |
| 2132 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2133 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2134 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 2135 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2136 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2137 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 2138 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2139 | |
| 2140 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2141 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 2142 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2143 | |
| 2144 | // Check whether this transaction is correctly marked as received a go-away |
| 2145 | // because of migrating port. |
| 2146 | NetErrorDetails details; |
| 2147 | EXPECT_FALSE(details.quic_port_migration_detected); |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 2148 | trans.PopulateNetErrorDetails(&details); |
zhongyi | 6b5a389 | 2016-03-12 04:46:20 | [diff] [blame] | 2149 | EXPECT_TRUE(details.quic_port_migration_detected); |
| 2150 | } |
| 2151 | |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2152 | // This test verifies that a new QUIC connection will be attempted on the |
| 2153 | // alternate network if the original QUIC connection fails with idle timeout |
| 2154 | // before handshake is confirmed. If TCP succeeds and QUIC fails on the |
| 2155 | // alternate network as well, QUIC is marked as broken and the brokenness will |
| 2156 | // not expire when default network changes. |
| 2157 | TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) { |
| 2158 | SetUpTestForRetryConnectionOnAlternateNetwork(); |
| 2159 | |
| 2160 | std::string request_data; |
| 2161 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2162 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
| 2163 | |
| 2164 | // The request will initially go out over QUIC. |
| 2165 | MockQuicData quic_data; |
| 2166 | quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| 2167 | int packet_num = 1; |
| 2168 | quic_data.AddWrite(SYNCHRONOUS, |
| 2169 | client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| 2170 | // Retranmit the handshake messages. |
| 2171 | quic_data.AddWrite(SYNCHRONOUS, |
| 2172 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2173 | quic_data.AddWrite(SYNCHRONOUS, |
| 2174 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2175 | quic_data.AddWrite(SYNCHRONOUS, |
| 2176 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2177 | quic_data.AddWrite(SYNCHRONOUS, |
| 2178 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2179 | // TODO(zhongyi): remove condition check once b/115926584 is fixed. |
| 2180 | if (version_ <= quic::QUIC_VERSION_39) { |
| 2181 | quic_data.AddWrite(SYNCHRONOUS, |
| 2182 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2183 | } |
| 2184 | // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| 2185 | quic_data.AddWrite(SYNCHRONOUS, |
| 2186 | client_maker_.MakeConnectionClosePacket( |
| 2187 | packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 2188 | "No recent network activity.")); |
| 2189 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2190 | |
| 2191 | // Add successful TCP data so that TCP job will succeed. |
| 2192 | MockWrite http_writes[] = { |
| 2193 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 2194 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 2195 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 2196 | |
| 2197 | MockRead http_reads[] = { |
| 2198 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 2199 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 2200 | MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)}; |
| 2201 | SequencedSocketData http_data(http_reads, http_writes); |
| 2202 | socket_factory_.AddSocketDataProvider(&http_data); |
| 2203 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2204 | |
| 2205 | // Add data for the second QUIC connection to fail. |
| 2206 | MockQuicData quic_data2; |
| 2207 | quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 2208 | quic_data2.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); // Write error. |
| 2209 | quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 2210 | |
| 2211 | // Resolve the host resolution synchronously. |
| 2212 | host_resolver_.set_synchronous_mode(true); |
| 2213 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2214 | ""); |
| 2215 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2216 | AddressList address; |
| 2217 | std::unique_ptr<HostResolver::Request> request; |
| 2218 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2219 | CompletionOnceCallback(), &request, |
| 2220 | net_log_.bound()); |
| 2221 | EXPECT_THAT(rv, IsOk()); |
| 2222 | |
| 2223 | CreateSession(); |
| 2224 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 2225 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| 2226 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 2227 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2228 | session_->quic_stream_factory(), |
| 2229 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 2230 | &clock_)); |
| 2231 | // Add alternate protocol mapping to race QUIC and TCP. |
| 2232 | // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| 2233 | // peer. |
| 2234 | AddQuicAlternateProtocolMapping( |
| 2235 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| 2236 | |
| 2237 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2238 | TestCompletionCallback callback; |
| 2239 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 2240 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2241 | |
| 2242 | // Pump the message loop to get the request started. |
| 2243 | // Request will be served with TCP job. |
| 2244 | base::RunLoop().RunUntilIdle(); |
| 2245 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 2246 | CheckResponseData(&trans, "TCP succeeds"); |
| 2247 | |
| 2248 | // Fire the retransmission alarm, from this point, connection will idle |
| 2249 | // timeout after 4 seconds. |
Zhongyi Shi | a15736c | 2018-09-25 00:31:18 | [diff] [blame] | 2250 | if (!quic::GetQuicReloadableFlag( |
| 2251 | quic_fix_time_of_first_packet_sent_after_receiving)) { |
| 2252 | quic_task_runner_->RunNextTask(); |
| 2253 | } |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2254 | // Fast forward to idle timeout the original connection. A new connection will |
| 2255 | // be kicked off on the alternate network. |
| 2256 | quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| 2257 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 2258 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2259 | |
| 2260 | // Run the message loop to execute posted tasks, which will report job status. |
| 2261 | base::RunLoop().RunUntilIdle(); |
| 2262 | |
| 2263 | // Verify that QUIC is marked as broken. |
| 2264 | ExpectBrokenAlternateProtocolMapping(); |
| 2265 | |
| 2266 | // Deliver a message to notify the new network becomes default, the brokenness |
| 2267 | // will not expire as QUIC is broken on both networks. |
| 2268 | scoped_mock_change_notifier_->mock_network_change_notifier() |
| 2269 | ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| 2270 | ExpectBrokenAlternateProtocolMapping(); |
| 2271 | |
| 2272 | ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| 2273 | ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| 2274 | } |
| 2275 | |
| 2276 | // This test verifies that a new QUIC connection will be attempted on the |
| 2277 | // alternate network if the original QUIC connection fails with idle timeout |
| 2278 | // before handshake is confirmed. If TCP succeeds and QUIC succeeds on the |
| 2279 | // alternate network, QUIC is marked as broken. The brokenness will expire when |
| 2280 | // the default network changes. |
| 2281 | TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) { |
| 2282 | SetUpTestForRetryConnectionOnAlternateNetwork(); |
| 2283 | |
| 2284 | std::string request_data; |
| 2285 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2286 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
| 2287 | |
| 2288 | // The request will initially go out over QUIC. |
| 2289 | MockQuicData quic_data; |
| 2290 | quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| 2291 | int packet_num = 1; |
| 2292 | quic_data.AddWrite(SYNCHRONOUS, |
| 2293 | client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| 2294 | // Retranmit the handshake messages. |
| 2295 | quic_data.AddWrite(SYNCHRONOUS, |
| 2296 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2297 | quic_data.AddWrite(SYNCHRONOUS, |
| 2298 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2299 | quic_data.AddWrite(SYNCHRONOUS, |
| 2300 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2301 | quic_data.AddWrite(SYNCHRONOUS, |
| 2302 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2303 | // TODO(zhongyi): remove condition check once b/115926584 is fixed. |
| 2304 | if (version_ <= quic::QUIC_VERSION_39) { |
| 2305 | quic_data.AddWrite(SYNCHRONOUS, |
| 2306 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2307 | } |
| 2308 | // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| 2309 | quic_data.AddWrite(SYNCHRONOUS, |
| 2310 | client_maker_.MakeConnectionClosePacket( |
| 2311 | packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 2312 | "No recent network activity.")); |
| 2313 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2314 | |
| 2315 | // Add successful TCP data so that TCP job will succeed. |
| 2316 | MockWrite http_writes[] = { |
| 2317 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 2318 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 2319 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 2320 | |
| 2321 | MockRead http_reads[] = { |
| 2322 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 2323 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 2324 | MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)}; |
| 2325 | SequencedSocketData http_data(http_reads, http_writes); |
| 2326 | socket_factory_.AddSocketDataProvider(&http_data); |
| 2327 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 2328 | |
| 2329 | // Quic connection will be retried on the alternate network after the initial |
| 2330 | // one fails on the default network. |
| 2331 | MockQuicData quic_data2; |
| 2332 | quic::QuicStreamOffset header_stream_offset = 0; |
| 2333 | quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Handing read. |
| 2334 | quic_data2.AddWrite(SYNCHRONOUS, |
| 2335 | client_maker_.MakeDummyCHLOPacket(1)); // CHLO |
| 2336 | |
| 2337 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| 2338 | quic_data2.AddWrite(SYNCHRONOUS, |
| 2339 | ConstructInitialSettingsPacket(2, &header_stream_offset)); |
| 2340 | quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 2341 | |
| 2342 | // Resolve the host resolution synchronously. |
| 2343 | host_resolver_.set_synchronous_mode(true); |
| 2344 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2345 | ""); |
| 2346 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2347 | AddressList address; |
| 2348 | std::unique_ptr<HostResolver::Request> request; |
| 2349 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2350 | CompletionOnceCallback(), &request, |
| 2351 | net_log_.bound()); |
| 2352 | EXPECT_THAT(rv, IsOk()); |
| 2353 | |
| 2354 | CreateSession(); |
| 2355 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 2356 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| 2357 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 2358 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2359 | session_->quic_stream_factory(), |
| 2360 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 2361 | &clock_)); |
| 2362 | // Add alternate protocol mapping to race QUIC and TCP. |
| 2363 | // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| 2364 | // peer. |
| 2365 | AddQuicAlternateProtocolMapping( |
| 2366 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| 2367 | |
| 2368 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2369 | TestCompletionCallback callback; |
| 2370 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 2371 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2372 | |
| 2373 | // Pump the message loop to get the request started. |
| 2374 | // Request will be served with TCP job. |
| 2375 | base::RunLoop().RunUntilIdle(); |
| 2376 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 2377 | CheckResponseData(&trans, "TCP succeeds"); |
| 2378 | |
| 2379 | // Fire the retransmission alarm, after which connection will idle |
| 2380 | // timeout after 4 seconds. |
Zhongyi Shi | a15736c | 2018-09-25 00:31:18 | [diff] [blame] | 2381 | if (!quic::GetQuicReloadableFlag( |
| 2382 | quic_fix_time_of_first_packet_sent_after_receiving)) { |
| 2383 | quic_task_runner_->RunNextTask(); |
| 2384 | } |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2385 | // Fast forward to idle timeout the original connection. A new connection will |
| 2386 | // be kicked off on the alternate network. |
| 2387 | quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| 2388 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 2389 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2390 | |
| 2391 | // The second connection hasn't finish handshake, verify that QUIC is not |
| 2392 | // marked as broken. |
| 2393 | ExpectQuicAlternateProtocolMapping(); |
| 2394 | // Explicitly confirm the handshake on the second connection. |
| 2395 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 2396 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 2397 | // Run message loop to execute posted tasks, which will notify JoController |
| 2398 | // about the orphaned job status. |
| 2399 | base::RunLoop().RunUntilIdle(); |
| 2400 | |
| 2401 | // Verify that QUIC is marked as broken. |
| 2402 | ExpectBrokenAlternateProtocolMapping(); |
| 2403 | |
| 2404 | // Deliver a message to notify the new network becomes default, the previous |
| 2405 | // brokenness will be clear as the brokenness is bond with old default |
| 2406 | // network. |
| 2407 | scoped_mock_change_notifier_->mock_network_change_notifier() |
| 2408 | ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| 2409 | ExpectQuicAlternateProtocolMapping(); |
| 2410 | |
| 2411 | ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| 2412 | ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| 2413 | } |
| 2414 | |
| 2415 | // This test verifies that a new QUIC connection will be attempted on the |
| 2416 | // alternate network if the original QUIC connection fails with idle timeout |
| 2417 | // before handshake is confirmed. If TCP doesn't succeed but QUIC on the |
| 2418 | // alternative network succeeds, QUIC is not marked as broken. |
| 2419 | TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPHanging) { |
| 2420 | SetUpTestForRetryConnectionOnAlternateNetwork(); |
| 2421 | |
| 2422 | std::string request_data; |
| 2423 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2424 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
| 2425 | |
| 2426 | // The request will initially go out over QUIC. |
| 2427 | MockQuicData quic_data; |
| 2428 | quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read |
| 2429 | int packet_num = 1; |
| 2430 | quic_data.AddWrite(SYNCHRONOUS, |
| 2431 | client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO |
| 2432 | // Retranmit the handshake messages. |
| 2433 | quic_data.AddWrite(SYNCHRONOUS, |
| 2434 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2435 | quic_data.AddWrite(SYNCHRONOUS, |
| 2436 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2437 | quic_data.AddWrite(SYNCHRONOUS, |
| 2438 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2439 | quic_data.AddWrite(SYNCHRONOUS, |
| 2440 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2441 | // TODO(zhongyi): remove condition check once b/115926584 is fixed, i.e., |
| 2442 | // quic_fix_has_pending_crypto_data is introduced and enabled. |
| 2443 | if (version_ <= quic::QUIC_VERSION_39) { |
| 2444 | quic_data.AddWrite(SYNCHRONOUS, |
| 2445 | client_maker_.MakeDummyCHLOPacket(packet_num++)); |
| 2446 | } |
| 2447 | // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT. |
| 2448 | quic_data.AddWrite(SYNCHRONOUS, |
| 2449 | client_maker_.MakeConnectionClosePacket( |
| 2450 | packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
| 2451 | "No recent network activity.")); |
| 2452 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2453 | |
| 2454 | // Add hanging TCP data so that TCP job will never succeeded. |
| 2455 | AddHangingNonAlternateProtocolSocketData(); |
| 2456 | |
| 2457 | // Quic connection will then be retried on the alternate network. |
| 2458 | MockQuicData quic_data2; |
| 2459 | quic::QuicStreamOffset header_stream_offset = 0; |
| 2460 | quic_data2.AddWrite(SYNCHRONOUS, |
| 2461 | client_maker_.MakeDummyCHLOPacket(1)); // CHLO |
| 2462 | |
| 2463 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| 2464 | quic_data2.AddWrite(SYNCHRONOUS, |
| 2465 | ConstructInitialSettingsPacket(2, &header_stream_offset)); |
| 2466 | quic_data2.AddWrite( |
| 2467 | SYNCHRONOUS, |
| 2468 | ConstructClientRequestHeadersPacket( |
| 2469 | 3, GetNthClientInitiatedStreamId(0), true, true, |
| 2470 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 2471 | quic_data2.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 2472 | 1, GetNthClientInitiatedStreamId(0), false, |
| 2473 | false, GetResponseHeaders("200 OK"))); |
| 2474 | quic_data2.AddRead( |
| 2475 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 2476 | false, true, 0, "hello!")); |
| 2477 | quic_data2.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 2, 1, 1)); |
| 2478 | quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 2479 | quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 2480 | |
| 2481 | // Resolve the host resolution synchronously. |
| 2482 | host_resolver_.set_synchronous_mode(true); |
| 2483 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2484 | ""); |
| 2485 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2486 | AddressList address; |
| 2487 | std::unique_ptr<HostResolver::Request> request; |
| 2488 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2489 | CompletionOnceCallback(), &request, |
| 2490 | net_log_.bound()); |
| 2491 | EXPECT_THAT(rv, IsOk()); |
| 2492 | |
| 2493 | CreateSession(); |
| 2494 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 2495 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| 2496 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 2497 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2498 | session_->quic_stream_factory(), |
| 2499 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 2500 | &clock_)); |
| 2501 | // Add alternate protocol mapping to race QUIC and TCP. |
| 2502 | // QUIC connection requires handshake to be confirmed and sends CHLO to the |
| 2503 | // peer. |
| 2504 | AddQuicAlternateProtocolMapping( |
| 2505 | MockCryptoClientStream::COLD_START_WITH_CHLO_SENT); |
| 2506 | |
| 2507 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2508 | TestCompletionCallback callback; |
| 2509 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 2510 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2511 | |
| 2512 | // Pump the message loop to get the request started. |
| 2513 | base::RunLoop().RunUntilIdle(); |
Zhongyi Shi | a15736c | 2018-09-25 00:31:18 | [diff] [blame] | 2514 | if (!quic::GetQuicReloadableFlag( |
| 2515 | quic_fix_time_of_first_packet_sent_after_receiving)) { |
| 2516 | quic_task_runner_->RunNextTask(); |
| 2517 | } |
Zhongyi Shi | a6b68d11 | 2018-09-24 07:49:03 | [diff] [blame] | 2518 | |
| 2519 | // Fast forward to idle timeout the original connection. A new connection will |
| 2520 | // be kicked off on the alternate network. |
| 2521 | quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4)); |
| 2522 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 2523 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2524 | |
| 2525 | // Verify that QUIC is not marked as broken. |
| 2526 | ExpectQuicAlternateProtocolMapping(); |
| 2527 | // Explicitly confirm the handshake on the second connection. |
| 2528 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 2529 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 2530 | |
| 2531 | // Read the response. |
| 2532 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 2533 | CheckResponseData(&trans, "hello!"); |
| 2534 | // Verify that QUIC is not marked as broken. |
| 2535 | ExpectQuicAlternateProtocolMapping(); |
| 2536 | |
| 2537 | // Deliver a message to notify the new network becomes default. |
| 2538 | scoped_mock_change_notifier_->mock_network_change_notifier() |
| 2539 | ->NotifyNetworkMadeDefault(kNewNetworkForTests); |
| 2540 | ExpectQuicAlternateProtocolMapping(); |
| 2541 | ASSERT_TRUE(quic_data2.AllReadDataConsumed()); |
| 2542 | ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); |
| 2543 | } |
| 2544 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2545 | // Verify that if a QUIC connection times out, the QuicHttpStream will |
| 2546 | // return QUIC_PROTOCOL_ERROR. |
| 2547 | TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 2548 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 2549 | session_params_.quic_idle_connection_timeout_seconds = 5; |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2550 | |
| 2551 | // The request will initially go out over QUIC. |
| 2552 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2553 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 2554 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2555 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 2556 | |
| 2557 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2558 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2559 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2560 | quic_data.AddWrite(SYNCHRONOUS, |
| 2561 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 2562 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 2563 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 2564 | nullptr, &header_stream_offset, &request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2565 | |
| 2566 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2567 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 2568 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2569 | quic_data.AddWrite(SYNCHRONOUS, |
| 2570 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 2571 | 2, &header_stream_offset, &settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2572 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2573 | quic_data.AddWrite( |
| 2574 | SYNCHRONOUS, client_maker_.MakeDataPacket(3, quic::kHeadersStreamId, true, |
| 2575 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2576 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2577 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2578 | 4, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2579 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2580 | // RTO 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2581 | quic_data.AddWrite( |
| 2582 | SYNCHRONOUS, client_maker_.MakeDataPacket(5, quic::kHeadersStreamId, true, |
| 2583 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2584 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2585 | 6, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2586 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2587 | // RTO 2 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2588 | quic_data.AddWrite( |
| 2589 | SYNCHRONOUS, client_maker_.MakeDataPacket(7, quic::kHeadersStreamId, true, |
| 2590 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2591 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2592 | 8, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2593 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2594 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2595 | quic_data.AddWrite( |
| 2596 | SYNCHRONOUS, client_maker_.MakeDataPacket(9, quic::kHeadersStreamId, true, |
| 2597 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2598 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2599 | 10, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2600 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2601 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2602 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2603 | 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2604 | "No recent network activity.")); |
Fan Yang | 928f163 | 2017-12-14 18:55:22 | [diff] [blame] | 2605 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2606 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 2607 | quic_data.AddRead(ASYNC, OK); |
| 2608 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2609 | |
| 2610 | // In order for a new QUIC session to be established via alternate-protocol |
| 2611 | // without racing an HTTP connection, we need the host resolution to happen |
| 2612 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2613 | // connection to the the server, in this test we require confirmation |
| 2614 | // before encrypting so the HTTP job will still start. |
| 2615 | host_resolver_.set_synchronous_mode(true); |
| 2616 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2617 | ""); |
| 2618 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2619 | AddressList address; |
| 2620 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 2621 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2622 | CompletionOnceCallback(), &request, |
| 2623 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2624 | EXPECT_THAT(rv, IsOk()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2625 | |
| 2626 | CreateSession(); |
| 2627 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2628 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2629 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2630 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 2631 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2632 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2633 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2634 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2635 | |
| 2636 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2637 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2638 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2639 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2640 | |
| 2641 | // Pump the message loop to get the request started. |
| 2642 | base::RunLoop().RunUntilIdle(); |
| 2643 | // Explicitly confirm the handshake. |
| 2644 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2645 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2646 | |
| 2647 | // Run the QUIC session to completion. |
| 2648 | quic_task_runner_->RunUntilIdle(); |
| 2649 | |
| 2650 | ExpectQuicAlternateProtocolMapping(); |
| 2651 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2652 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 2653 | } |
| 2654 | |
| 2655 | // Verify that if a QUIC connection RTOs, the QuicHttpStream will |
| 2656 | // return QUIC_PROTOCOL_ERROR. |
| 2657 | TEST_P(QuicNetworkTransactionTest, TooManyRtosAfterHandshakeConfirmed) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 2658 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2659 | session_params_.quic_connection_options.push_back(quic::k5RTO); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2660 | |
| 2661 | // The request will initially go out over QUIC. |
| 2662 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2663 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 2664 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2665 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 2666 | |
| 2667 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2668 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2669 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2670 | quic_data.AddWrite(SYNCHRONOUS, |
| 2671 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 2672 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 2673 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 2674 | nullptr, &header_stream_offset, &request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2675 | |
| 2676 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2677 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 2678 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2679 | quic_data.AddWrite(SYNCHRONOUS, |
| 2680 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 2681 | 2, &header_stream_offset, &settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2682 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2683 | quic_data.AddWrite( |
| 2684 | SYNCHRONOUS, client_maker_.MakeDataPacket(3, quic::kHeadersStreamId, true, |
| 2685 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2686 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2687 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2688 | 4, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2689 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2690 | // RTO 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2691 | quic_data.AddWrite( |
| 2692 | SYNCHRONOUS, client_maker_.MakeDataPacket(5, quic::kHeadersStreamId, true, |
| 2693 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2694 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2695 | 6, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2696 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2697 | // RTO 2 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2698 | quic_data.AddWrite( |
| 2699 | SYNCHRONOUS, client_maker_.MakeDataPacket(7, quic::kHeadersStreamId, true, |
| 2700 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2701 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2702 | 8, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2703 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2704 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2705 | quic_data.AddWrite( |
| 2706 | SYNCHRONOUS, client_maker_.MakeDataPacket(9, quic::kHeadersStreamId, true, |
| 2707 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2708 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2709 | 10, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2710 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2711 | // RTO 4 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2712 | quic_data.AddWrite( |
| 2713 | SYNCHRONOUS, client_maker_.MakeDataPacket(11, quic::kHeadersStreamId, |
| 2714 | true, false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2715 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2716 | 12, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2717 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2718 | // RTO 5 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2719 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2720 | 13, true, quic::QUIC_TOO_MANY_RTOS, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2721 | "5 consecutive retransmission timeouts")); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2722 | |
| 2723 | quic_data.AddRead(ASYNC, OK); |
| 2724 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2725 | |
| 2726 | // In order for a new QUIC session to be established via alternate-protocol |
| 2727 | // without racing an HTTP connection, we need the host resolution to happen |
| 2728 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2729 | // connection to the the server, in this test we require confirmation |
| 2730 | // before encrypting so the HTTP job will still start. |
| 2731 | host_resolver_.set_synchronous_mode(true); |
| 2732 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2733 | ""); |
| 2734 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2735 | AddressList address; |
| 2736 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 2737 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2738 | CompletionOnceCallback(), &request, |
| 2739 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2740 | EXPECT_THAT(rv, IsOk()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2741 | |
| 2742 | CreateSession(); |
| 2743 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2744 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2745 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2746 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 2747 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2748 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2749 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2750 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2751 | |
| 2752 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2753 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2754 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2755 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2756 | |
| 2757 | // Pump the message loop to get the request started. |
| 2758 | base::RunLoop().RunUntilIdle(); |
| 2759 | // Explicitly confirm the handshake. |
| 2760 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2761 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2762 | |
| 2763 | // Run the QUIC session to completion. |
| 2764 | quic_task_runner_->RunUntilIdle(); |
| 2765 | |
| 2766 | ExpectQuicAlternateProtocolMapping(); |
| 2767 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2768 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 2769 | } |
| 2770 | |
| 2771 | // Verify that if a QUIC connection RTOs, while there are no active streams |
| 2772 | // QUIC will not be marked as broken. |
| 2773 | TEST_P(QuicNetworkTransactionTest, |
| 2774 | TooManyRtosAfterHandshakeConfirmedAndStreamReset) { |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2775 | session_params_.quic_connection_options.push_back(quic::k5RTO); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2776 | |
| 2777 | // The request will initially go out over QUIC. |
| 2778 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2779 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 2780 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2781 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 2782 | |
| 2783 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2784 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2785 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2786 | quic_data.AddWrite(SYNCHRONOUS, |
| 2787 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 2788 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 2789 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 2790 | nullptr, &header_stream_offset, &request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2791 | |
| 2792 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2793 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 2794 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2795 | quic_data.AddWrite(SYNCHRONOUS, |
| 2796 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 2797 | 2, &header_stream_offset, &settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2798 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2799 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket( |
| 2800 | 3, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2801 | quic::QUIC_STREAM_CANCELLED)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2802 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2803 | quic_data.AddWrite( |
| 2804 | SYNCHRONOUS, client_maker_.MakeDataPacket(4, quic::kHeadersStreamId, true, |
| 2805 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2806 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2807 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2808 | 5, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2809 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2810 | // RTO 1 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2811 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket( |
| 2812 | 6, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2813 | quic::QUIC_STREAM_CANCELLED)); |
| 2814 | quic_data.AddWrite( |
| 2815 | SYNCHRONOUS, client_maker_.MakeDataPacket(7, quic::kHeadersStreamId, true, |
| 2816 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2817 | // RTO 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2818 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2819 | 8, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2820 | settings_offset, settings_data)); |
| 2821 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket( |
| 2822 | 9, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2823 | quic::QUIC_STREAM_CANCELLED)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2824 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2825 | quic_data.AddWrite( |
| 2826 | SYNCHRONOUS, client_maker_.MakeDataPacket(10, quic::kHeadersStreamId, |
| 2827 | true, false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2828 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2829 | 11, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2830 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2831 | // RTO 4 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2832 | quic_data.AddWrite( |
| 2833 | SYNCHRONOUS, |
| 2834 | client_maker_.MakeRstPacket(12, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2835 | quic::QUIC_STREAM_CANCELLED)); |
| 2836 | quic_data.AddWrite( |
| 2837 | SYNCHRONOUS, client_maker_.MakeDataPacket(13, quic::kHeadersStreamId, |
| 2838 | true, false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2839 | // RTO 5 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2840 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2841 | 14, true, quic::QUIC_TOO_MANY_RTOS, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2842 | "5 consecutive retransmission timeouts")); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2843 | |
| 2844 | quic_data.AddRead(ASYNC, OK); |
| 2845 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2846 | |
| 2847 | // In order for a new QUIC session to be established via alternate-protocol |
| 2848 | // without racing an HTTP connection, we need the host resolution to happen |
| 2849 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2850 | // connection to the the server, in this test we require confirmation |
| 2851 | // before encrypting so the HTTP job will still start. |
| 2852 | host_resolver_.set_synchronous_mode(true); |
| 2853 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2854 | ""); |
| 2855 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2856 | AddressList address; |
| 2857 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 2858 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2859 | CompletionOnceCallback(), &request, |
| 2860 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2861 | EXPECT_THAT(rv, IsOk()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2862 | |
| 2863 | CreateSession(); |
| 2864 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2865 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2866 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 2867 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 2868 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 2869 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2870 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2871 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2872 | |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 2873 | auto trans = std::make_unique<HttpNetworkTransaction>(DEFAULT_PRIORITY, |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2874 | session_.get()); |
| 2875 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2876 | rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2877 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2878 | |
| 2879 | // Pump the message loop to get the request started. |
| 2880 | base::RunLoop().RunUntilIdle(); |
| 2881 | // Explicitly confirm the handshake. |
| 2882 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2883 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2884 | |
| 2885 | // Now cancel the request. |
| 2886 | trans.reset(); |
| 2887 | |
| 2888 | // Run the QUIC session to completion. |
| 2889 | quic_task_runner_->RunUntilIdle(); |
| 2890 | |
| 2891 | ExpectQuicAlternateProtocolMapping(); |
| 2892 | |
| 2893 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2894 | } |
| 2895 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2896 | // Verify that if a QUIC protocol error occurs after the handshake is confirmed |
| 2897 | // the request fails with QUIC_PROTOCOL_ERROR. |
| 2898 | TEST_P(QuicNetworkTransactionTest, ProtocolErrorAfterHandshakeConfirmed) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 2899 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2900 | // The request will initially go out over QUIC. |
| 2901 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2902 | quic::QuicStreamOffset header_stream_offset = 0; |
| 2903 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2904 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2905 | quic_data.AddWrite( |
| 2906 | SYNCHRONOUS, |
| 2907 | ConstructClientRequestHeadersPacket( |
| 2908 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 2909 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2910 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2911 | quic_data.AddWrite(SYNCHRONOUS, |
| 2912 | ConstructInitialSettingsPacket(2, &header_stream_offset)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2913 | // Peer sending data from an non-existing stream causes this end to raise |
| 2914 | // error and close connection. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2915 | quic_data.AddRead(ASYNC, ConstructServerRstPacket( |
| 2916 | 1, false, 99, quic::QUIC_STREAM_LAST_ERROR)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2917 | std::string quic_error_details = "Data for nonexistent stream"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2918 | quic_data.AddWrite(SYNCHRONOUS, |
| 2919 | ConstructClientAckAndConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2920 | 3, quic::QuicTime::Delta::Zero(), 1, 1, 1, |
| 2921 | quic::QUIC_INVALID_STREAM_ID, quic_error_details)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2922 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 2923 | |
| 2924 | // In order for a new QUIC session to be established via alternate-protocol |
| 2925 | // without racing an HTTP connection, we need the host resolution to happen |
| 2926 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 2927 | // connection to the the server, in this test we require confirmation |
| 2928 | // before encrypting so the HTTP job will still start. |
| 2929 | host_resolver_.set_synchronous_mode(true); |
| 2930 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 2931 | ""); |
| 2932 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 2933 | AddressList address; |
| 2934 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 2935 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 2936 | CompletionOnceCallback(), &request, |
| 2937 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2938 | EXPECT_THAT(rv, IsOk()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2939 | |
| 2940 | CreateSession(); |
| 2941 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 2942 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2943 | |
| 2944 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 2945 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 2946 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2947 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 2948 | |
| 2949 | // Pump the message loop to get the request started. |
| 2950 | base::RunLoop().RunUntilIdle(); |
| 2951 | // Explicitly confirm the handshake. |
| 2952 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2953 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 2954 | |
| 2955 | ASSERT_FALSE(quic_data.AllReadDataConsumed()); |
| 2956 | |
| 2957 | // Run the QUIC session to completion. |
| 2958 | base::RunLoop().RunUntilIdle(); |
| 2959 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2960 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
| 2961 | |
| 2962 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 2963 | ExpectQuicAlternateProtocolMapping(); |
| 2964 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 2965 | } |
| 2966 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2967 | // Verify that with mark_quic_broken_when_network_blackholes enabled, if a QUIC |
| 2968 | // connection times out, then QUIC will be marked as broken and the request |
| 2969 | // retried over TCP. |
| 2970 | TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 2971 | session_params_.mark_quic_broken_when_network_blackholes = true; |
| 2972 | session_params_.quic_idle_connection_timeout_seconds = 5; |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2973 | |
| 2974 | // The request will initially go out over QUIC. |
| 2975 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2976 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 2977 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2978 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 2979 | |
| 2980 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2981 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 2982 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2983 | quic_data.AddWrite(SYNCHRONOUS, |
| 2984 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 2985 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 2986 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 2987 | nullptr, &header_stream_offset, &request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2988 | |
| 2989 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2990 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 2991 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 2992 | quic_data.AddWrite(SYNCHRONOUS, |
| 2993 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 2994 | 2, &header_stream_offset, &settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2995 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 2996 | quic_data.AddWrite( |
| 2997 | SYNCHRONOUS, client_maker_.MakeDataPacket(3, quic::kHeadersStreamId, true, |
| 2998 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 2999 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3000 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3001 | 4, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3002 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3003 | // RTO 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3004 | quic_data.AddWrite( |
| 3005 | SYNCHRONOUS, client_maker_.MakeDataPacket(5, quic::kHeadersStreamId, true, |
| 3006 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3007 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3008 | 6, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3009 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3010 | // RTO 2 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3011 | quic_data.AddWrite( |
| 3012 | SYNCHRONOUS, client_maker_.MakeDataPacket(7, quic::kHeadersStreamId, true, |
| 3013 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3014 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3015 | 8, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3016 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3017 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3018 | quic_data.AddWrite( |
| 3019 | SYNCHRONOUS, client_maker_.MakeDataPacket(9, quic::kHeadersStreamId, true, |
| 3020 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3021 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3022 | 10, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3023 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3024 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3025 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3026 | 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3027 | "No recent network activity.")); |
Fan Yang | 928f163 | 2017-12-14 18:55:22 | [diff] [blame] | 3028 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3029 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 3030 | quic_data.AddRead(ASYNC, OK); |
| 3031 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3032 | |
| 3033 | // After that fails, it will be resent via TCP. |
| 3034 | MockWrite http_writes[] = { |
| 3035 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3036 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3037 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3038 | |
| 3039 | MockRead http_reads[] = { |
| 3040 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3041 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3042 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3043 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3044 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3045 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3046 | |
| 3047 | // In order for a new QUIC session to be established via alternate-protocol |
| 3048 | // without racing an HTTP connection, we need the host resolution to happen |
| 3049 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3050 | // connection to the the server, in this test we require confirmation |
| 3051 | // before encrypting so the HTTP job will still start. |
| 3052 | host_resolver_.set_synchronous_mode(true); |
| 3053 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3054 | ""); |
| 3055 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 3056 | AddressList address; |
| 3057 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 3058 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 3059 | CompletionOnceCallback(), &request, |
| 3060 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3061 | EXPECT_THAT(rv, IsOk()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3062 | |
| 3063 | CreateSession(); |
| 3064 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3065 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3066 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3067 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3068 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3069 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3070 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3071 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3072 | |
| 3073 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3074 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3075 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3076 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3077 | |
| 3078 | // Pump the message loop to get the request started. |
| 3079 | base::RunLoop().RunUntilIdle(); |
| 3080 | // Explicitly confirm the handshake. |
| 3081 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3082 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3083 | |
| 3084 | // Run the QUIC session to completion. |
| 3085 | quic_task_runner_->RunUntilIdle(); |
| 3086 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3087 | |
| 3088 | // Let the transaction proceed which will result in QUIC being marked |
| 3089 | // as broken and the request falling back to TCP. |
| 3090 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3091 | |
| 3092 | ExpectBrokenAlternateProtocolMapping(); |
| 3093 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3094 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3095 | |
| 3096 | // Read the response body over TCP. |
| 3097 | CheckResponseData(&trans, "hello world"); |
| 3098 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3099 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3100 | } |
| 3101 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3102 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3103 | // connection times out, then QUIC will be marked as broken and the request |
| 3104 | // retried over TCP. |
| 3105 | TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken2) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 3106 | session_params_.quic_idle_connection_timeout_seconds = 5; |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3107 | |
| 3108 | // The request will initially go out over QUIC. |
| 3109 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3110 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 3111 | spdy::SpdyPriority priority = |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3112 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 3113 | |
| 3114 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3115 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 3116 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3117 | quic_data.AddWrite(SYNCHRONOUS, |
| 3118 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 3119 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 3120 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 3121 | nullptr, &header_stream_offset, &request_data)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3122 | |
| 3123 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3124 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 3125 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3126 | quic_data.AddWrite(SYNCHRONOUS, |
| 3127 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 3128 | 2, &header_stream_offset, &settings_data)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3129 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3130 | quic_data.AddWrite( |
| 3131 | SYNCHRONOUS, client_maker_.MakeDataPacket(3, quic::kHeadersStreamId, true, |
| 3132 | false, 0, request_data)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3133 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3134 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3135 | 4, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3136 | settings_offset, settings_data)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3137 | // RTO 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3138 | quic_data.AddWrite( |
| 3139 | SYNCHRONOUS, client_maker_.MakeDataPacket(5, quic::kHeadersStreamId, true, |
| 3140 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3141 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3142 | 6, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3143 | settings_offset, settings_data)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3144 | // RTO 2 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3145 | quic_data.AddWrite( |
| 3146 | SYNCHRONOUS, client_maker_.MakeDataPacket(7, quic::kHeadersStreamId, true, |
| 3147 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3148 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3149 | 8, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3150 | settings_offset, settings_data)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3151 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3152 | quic_data.AddWrite( |
| 3153 | SYNCHRONOUS, client_maker_.MakeDataPacket(9, quic::kHeadersStreamId, true, |
| 3154 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3155 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3156 | 10, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3157 | settings_offset, settings_data)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3158 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3159 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3160 | 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3161 | "No recent network activity.")); |
Fan Yang | 928f163 | 2017-12-14 18:55:22 | [diff] [blame] | 3162 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3163 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 3164 | quic_data.AddRead(ASYNC, OK); |
| 3165 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3166 | |
| 3167 | // After that fails, it will be resent via TCP. |
| 3168 | MockWrite http_writes[] = { |
| 3169 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3170 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3171 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3172 | |
| 3173 | MockRead http_reads[] = { |
| 3174 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3175 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3176 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3177 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3178 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3179 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3180 | |
| 3181 | // In order for a new QUIC session to be established via alternate-protocol |
| 3182 | // without racing an HTTP connection, we need the host resolution to happen |
| 3183 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3184 | // connection to the the server, in this test we require confirmation |
| 3185 | // before encrypting so the HTTP job will still start. |
| 3186 | host_resolver_.set_synchronous_mode(true); |
| 3187 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3188 | ""); |
| 3189 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 3190 | AddressList address; |
| 3191 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 3192 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 3193 | CompletionOnceCallback(), &request, |
| 3194 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3195 | EXPECT_THAT(rv, IsOk()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3196 | |
| 3197 | CreateSession(); |
| 3198 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3199 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3200 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3201 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3202 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3203 | &clock_)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3204 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3205 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3206 | |
| 3207 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3208 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3209 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3210 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3211 | |
| 3212 | // Pump the message loop to get the request started. |
| 3213 | base::RunLoop().RunUntilIdle(); |
| 3214 | // Explicitly confirm the handshake. |
| 3215 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3216 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3217 | |
| 3218 | // Run the QUIC session to completion. |
| 3219 | quic_task_runner_->RunUntilIdle(); |
| 3220 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3221 | |
| 3222 | ExpectQuicAlternateProtocolMapping(); |
| 3223 | |
| 3224 | // Let the transaction proceed which will result in QUIC being marked |
| 3225 | // as broken and the request falling back to TCP. |
| 3226 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3227 | |
| 3228 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3229 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3230 | |
| 3231 | // Read the response body over TCP. |
| 3232 | CheckResponseData(&trans, "hello world"); |
| 3233 | ExpectBrokenAlternateProtocolMapping(); |
| 3234 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3235 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3236 | } |
| 3237 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3238 | // Verify that with mark_quic_broken_when_network_blackholes enabled, if a QUIC |
| 3239 | // connection times out, then QUIC will be marked as broken but the request |
| 3240 | // will not be retried over TCP. |
| 3241 | TEST_P(QuicNetworkTransactionTest, |
| 3242 | TimeoutAfterHandshakeConfirmedAndHeadersThenBrokenNotRetried) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 3243 | session_params_.mark_quic_broken_when_network_blackholes = true; |
| 3244 | session_params_.quic_idle_connection_timeout_seconds = 5; |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3245 | |
| 3246 | // The request will initially go out over QUIC. |
| 3247 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3248 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 3249 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3250 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 3251 | |
| 3252 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3253 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 3254 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3255 | quic_data.AddWrite(SYNCHRONOUS, |
| 3256 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 3257 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 3258 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 3259 | nullptr, &header_stream_offset, &request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3260 | |
| 3261 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3262 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 3263 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3264 | quic_data.AddWrite(SYNCHRONOUS, |
| 3265 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 3266 | 2, &header_stream_offset, &settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3267 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3268 | quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 3269 | 1, GetNthClientInitiatedStreamId(0), false, |
| 3270 | false, GetResponseHeaders("200 OK"))); |
| 3271 | // quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 1, 1)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3272 | quic_data.AddWrite( |
| 3273 | SYNCHRONOUS, |
| 3274 | ConstructClientAckPacket(3, 1, 1, 1, |
| 3275 | quic::QuicTime::Delta::FromMilliseconds(25))); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3276 | |
| 3277 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3278 | quic_data.AddWrite( |
| 3279 | SYNCHRONOUS, client_maker_.MakeDataPacket(4, quic::kHeadersStreamId, |
| 3280 | false, false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3281 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3282 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3283 | 5, quic::kHeadersStreamId, false, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3284 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3285 | // RTO 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3286 | quic_data.AddWrite( |
| 3287 | SYNCHRONOUS, client_maker_.MakeDataPacket(6, quic::kHeadersStreamId, |
| 3288 | false, false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3289 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3290 | 7, quic::kHeadersStreamId, false, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3291 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3292 | // RTO 2 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3293 | quic_data.AddWrite( |
| 3294 | SYNCHRONOUS, client_maker_.MakeDataPacket(8, quic::kHeadersStreamId, |
| 3295 | false, false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3296 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3297 | 9, quic::kHeadersStreamId, false, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3298 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3299 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3300 | quic_data.AddWrite( |
| 3301 | SYNCHRONOUS, client_maker_.MakeDataPacket(10, quic::kHeadersStreamId, |
| 3302 | false, false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3303 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3304 | 11, quic::kHeadersStreamId, false, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3305 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3306 | |
Zhongyi Shi | a15736c | 2018-09-25 00:31:18 | [diff] [blame] | 3307 | if (quic::GetQuicReloadableFlag( |
| 3308 | quic_fix_time_of_first_packet_sent_after_receiving)) { |
| 3309 | quic_data.AddWrite( |
| 3310 | SYNCHRONOUS, |
| 3311 | client_maker_.MakeAckAndConnectionClosePacket( |
| 3312 | 12, false, quic::QuicTime::Delta::FromMilliseconds(4000), 1, 1, 1, |
| 3313 | quic::QUIC_NETWORK_IDLE_TIMEOUT, "No recent network activity.")); |
| 3314 | |
| 3315 | } else { |
| 3316 | quic_data.AddWrite( |
| 3317 | SYNCHRONOUS, |
| 3318 | client_maker_.MakeAckAndConnectionClosePacket( |
| 3319 | 12, false, quic::QuicTime::Delta::FromMilliseconds(4200), 1, 1, 1, |
| 3320 | quic::QUIC_NETWORK_IDLE_TIMEOUT, "No recent network activity.")); |
| 3321 | } |
Fan Yang | 928f163 | 2017-12-14 18:55:22 | [diff] [blame] | 3322 | |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3323 | quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 3324 | quic_data.AddRead(ASYNC, OK); |
| 3325 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3326 | |
| 3327 | // In order for a new QUIC session to be established via alternate-protocol |
| 3328 | // without racing an HTTP connection, we need the host resolution to happen |
| 3329 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3330 | // connection to the the server, in this test we require confirmation |
| 3331 | // before encrypting so the HTTP job will still start. |
| 3332 | host_resolver_.set_synchronous_mode(true); |
| 3333 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3334 | ""); |
| 3335 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 3336 | AddressList address; |
| 3337 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 3338 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 3339 | CompletionOnceCallback(), &request, |
| 3340 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3341 | EXPECT_THAT(rv, IsOk()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3342 | |
| 3343 | CreateSession(); |
| 3344 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3345 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3346 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3347 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3348 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3349 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3350 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3351 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3352 | |
| 3353 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3354 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3355 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3356 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3357 | |
| 3358 | // Pump the message loop to get the request started. |
| 3359 | base::RunLoop().RunUntilIdle(); |
| 3360 | // Explicitly confirm the handshake. |
| 3361 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3362 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3363 | |
| 3364 | // Pump the message loop to get the request started. |
| 3365 | base::RunLoop().RunUntilIdle(); |
| 3366 | |
| 3367 | // Run the QUIC session to completion. |
| 3368 | quic_task_runner_->RunUntilIdle(); |
| 3369 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3370 | |
| 3371 | // Let the transaction proceed which will result in QUIC being marked |
| 3372 | // as broken and the request falling back to TCP. |
| 3373 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3374 | |
| 3375 | ExpectBrokenAlternateProtocolMapping(); |
| 3376 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3377 | |
| 3378 | std::string response_data; |
| 3379 | ASSERT_THAT(ReadTransaction(&trans, &response_data), |
| 3380 | IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 3381 | } |
| 3382 | |
| 3383 | // Verify that with mark_quic_broken_when_network_blackholes enabled, if a QUIC |
| 3384 | // connection RTOs, then QUIC will be marked as broken and the request retried |
| 3385 | // over TCP. |
| 3386 | TEST_P(QuicNetworkTransactionTest, |
| 3387 | TooManyRtosAfterHandshakeConfirmedThenBroken) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 3388 | session_params_.mark_quic_broken_when_network_blackholes = true; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3389 | session_params_.quic_connection_options.push_back(quic::k5RTO); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3390 | |
| 3391 | // The request will initially go out over QUIC. |
| 3392 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3393 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 3394 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3395 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 3396 | |
| 3397 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3398 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 3399 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3400 | quic_data.AddWrite(SYNCHRONOUS, |
| 3401 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 3402 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 3403 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 3404 | nullptr, &header_stream_offset, &request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3405 | |
| 3406 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3407 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 3408 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3409 | quic_data.AddWrite(SYNCHRONOUS, |
| 3410 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 3411 | 2, &header_stream_offset, &settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3412 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3413 | quic_data.AddWrite( |
| 3414 | SYNCHRONOUS, client_maker_.MakeDataPacket(3, quic::kHeadersStreamId, true, |
| 3415 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3416 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3417 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3418 | 4, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3419 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3420 | // RTO 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3421 | quic_data.AddWrite( |
| 3422 | SYNCHRONOUS, client_maker_.MakeDataPacket(5, quic::kHeadersStreamId, true, |
| 3423 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3424 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3425 | 6, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3426 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3427 | // RTO 2 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3428 | quic_data.AddWrite( |
| 3429 | SYNCHRONOUS, client_maker_.MakeDataPacket(7, quic::kHeadersStreamId, true, |
| 3430 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3431 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3432 | 8, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3433 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3434 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3435 | quic_data.AddWrite( |
| 3436 | SYNCHRONOUS, client_maker_.MakeDataPacket(9, quic::kHeadersStreamId, true, |
| 3437 | false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3438 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3439 | 10, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3440 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3441 | // RTO 4 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3442 | quic_data.AddWrite( |
| 3443 | SYNCHRONOUS, client_maker_.MakeDataPacket(11, quic::kHeadersStreamId, |
| 3444 | true, false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3445 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3446 | 12, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3447 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3448 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3449 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3450 | 13, true, quic::QUIC_TOO_MANY_RTOS, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3451 | "5 consecutive retransmission timeouts")); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3452 | |
| 3453 | quic_data.AddRead(ASYNC, OK); |
| 3454 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3455 | |
| 3456 | // After that fails, it will be resent via TCP. |
| 3457 | MockWrite http_writes[] = { |
| 3458 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3459 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3460 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3461 | |
| 3462 | MockRead http_reads[] = { |
| 3463 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3464 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3465 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3466 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3467 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3468 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3469 | |
| 3470 | // In order for a new QUIC session to be established via alternate-protocol |
| 3471 | // without racing an HTTP connection, we need the host resolution to happen |
| 3472 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3473 | // connection to the the server, in this test we require confirmation |
| 3474 | // before encrypting so the HTTP job will still start. |
| 3475 | host_resolver_.set_synchronous_mode(true); |
| 3476 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3477 | ""); |
| 3478 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 3479 | AddressList address; |
| 3480 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 3481 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 3482 | CompletionOnceCallback(), &request, |
| 3483 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3484 | EXPECT_THAT(rv, IsOk()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3485 | |
| 3486 | CreateSession(); |
| 3487 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3488 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3489 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3490 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3491 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3492 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3493 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3494 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3495 | |
| 3496 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3497 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3498 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3499 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3500 | |
| 3501 | // Pump the message loop to get the request started. |
| 3502 | base::RunLoop().RunUntilIdle(); |
| 3503 | // Explicitly confirm the handshake. |
| 3504 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3505 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3506 | |
| 3507 | // Run the QUIC session to completion. |
| 3508 | quic_task_runner_->RunUntilIdle(); |
| 3509 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3510 | |
| 3511 | // Let the transaction proceed which will result in QUIC being marked |
| 3512 | // as broken and the request falling back to TCP. |
| 3513 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3514 | |
| 3515 | ExpectBrokenAlternateProtocolMapping(); |
| 3516 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3517 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3518 | |
| 3519 | // Read the response body over TCP. |
| 3520 | CheckResponseData(&trans, "hello world"); |
| 3521 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3522 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3523 | } |
| 3524 | |
| 3525 | // Verify that if a QUIC connection RTOs, while there are no active streams |
| 3526 | // QUIC will be marked as broken. |
| 3527 | TEST_P(QuicNetworkTransactionTest, |
| 3528 | TooManyRtosAfterHandshakeConfirmedAndStreamResetThenBroken) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 3529 | session_params_.mark_quic_broken_when_network_blackholes = true; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3530 | session_params_.quic_connection_options.push_back(quic::k5RTO); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3531 | |
| 3532 | // The request will initially go out over QUIC. |
| 3533 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3534 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 3535 | spdy::SpdyPriority priority = |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3536 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 3537 | |
| 3538 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3539 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 3540 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3541 | quic_data.AddWrite(SYNCHRONOUS, |
| 3542 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 3543 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 3544 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 3545 | nullptr, &header_stream_offset, &request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3546 | |
| 3547 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3548 | quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 3549 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3550 | quic_data.AddWrite(SYNCHRONOUS, |
| 3551 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 3552 | 2, &header_stream_offset, &settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3553 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3554 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket( |
| 3555 | 3, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3556 | quic::QUIC_STREAM_CANCELLED)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3557 | // TLP 1 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3558 | quic_data.AddWrite( |
| 3559 | SYNCHRONOUS, client_maker_.MakeDataPacket(4, quic::kHeadersStreamId, true, |
| 3560 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3561 | // TLP 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3562 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3563 | 5, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3564 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3565 | // RTO 1 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3566 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket( |
| 3567 | 6, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3568 | quic::QUIC_STREAM_CANCELLED)); |
| 3569 | quic_data.AddWrite( |
| 3570 | SYNCHRONOUS, client_maker_.MakeDataPacket(7, quic::kHeadersStreamId, true, |
| 3571 | false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3572 | // RTO 2 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3573 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3574 | 8, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3575 | settings_offset, settings_data)); |
| 3576 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeRstPacket( |
| 3577 | 9, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3578 | quic::QUIC_STREAM_CANCELLED)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3579 | // RTO 3 |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3580 | quic_data.AddWrite( |
| 3581 | SYNCHRONOUS, client_maker_.MakeDataPacket(10, quic::kHeadersStreamId, |
| 3582 | true, false, 0, request_data)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3583 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDataPacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3584 | 11, quic::kHeadersStreamId, true, false, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3585 | settings_offset, settings_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3586 | // RTO 4 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3587 | quic_data.AddWrite( |
| 3588 | SYNCHRONOUS, |
| 3589 | client_maker_.MakeRstPacket(12, true, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3590 | quic::QUIC_STREAM_CANCELLED)); |
| 3591 | quic_data.AddWrite( |
| 3592 | SYNCHRONOUS, client_maker_.MakeDataPacket(13, quic::kHeadersStreamId, |
| 3593 | true, false, 0, request_data)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3594 | // RTO 5 |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3595 | quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3596 | 14, true, quic::QUIC_TOO_MANY_RTOS, |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3597 | "5 consecutive retransmission timeouts")); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3598 | |
| 3599 | quic_data.AddRead(ASYNC, OK); |
| 3600 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3601 | |
| 3602 | // In order for a new QUIC session to be established via alternate-protocol |
| 3603 | // without racing an HTTP connection, we need the host resolution to happen |
| 3604 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3605 | // connection to the the server, in this test we require confirmation |
| 3606 | // before encrypting so the HTTP job will still start. |
| 3607 | host_resolver_.set_synchronous_mode(true); |
| 3608 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3609 | ""); |
| 3610 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 3611 | AddressList address; |
| 3612 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 3613 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 3614 | CompletionOnceCallback(), &request, |
| 3615 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3616 | EXPECT_THAT(rv, IsOk()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3617 | |
| 3618 | CreateSession(); |
| 3619 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3620 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3621 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 3622 | session_->quic_stream_factory(), |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3623 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 3624 | &clock_)); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3625 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3626 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3627 | |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 3628 | auto trans = std::make_unique<HttpNetworkTransaction>(DEFAULT_PRIORITY, |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3629 | session_.get()); |
| 3630 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3631 | rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3632 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3633 | |
| 3634 | // Pump the message loop to get the request started. |
| 3635 | base::RunLoop().RunUntilIdle(); |
| 3636 | // Explicitly confirm the handshake. |
| 3637 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3638 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 9ecde09b | 2017-04-08 00:18:23 | [diff] [blame] | 3639 | |
| 3640 | // Now cancel the request. |
| 3641 | trans.reset(); |
| 3642 | |
| 3643 | // Run the QUIC session to completion. |
| 3644 | quic_task_runner_->RunUntilIdle(); |
| 3645 | |
| 3646 | ExpectBrokenAlternateProtocolMapping(); |
| 3647 | |
| 3648 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3649 | } |
| 3650 | |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3651 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3652 | // protocol error occurs after the handshake is confirmed, the request |
| 3653 | // retried over TCP and the QUIC will be marked as broken. |
| 3654 | TEST_P(QuicNetworkTransactionTest, |
| 3655 | ProtocolErrorAfterHandshakeConfirmedThenBroken) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 3656 | session_params_.quic_idle_connection_timeout_seconds = 5; |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3657 | |
| 3658 | // The request will initially go out over QUIC. |
| 3659 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3660 | quic::QuicStreamOffset header_stream_offset = 0; |
| 3661 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 3662 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3663 | quic_data.AddWrite( |
| 3664 | SYNCHRONOUS, |
| 3665 | ConstructClientRequestHeadersPacket( |
| 3666 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 3667 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3668 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3669 | quic_data.AddWrite(SYNCHRONOUS, |
| 3670 | ConstructInitialSettingsPacket(2, &header_stream_offset)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3671 | // Peer sending data from an non-existing stream causes this end to raise |
| 3672 | // error and close connection. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3673 | quic_data.AddRead(ASYNC, ConstructServerRstPacket( |
| 3674 | 1, false, 99, quic::QUIC_STREAM_LAST_ERROR)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3675 | std::string quic_error_details = "Data for nonexistent stream"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3676 | quic_data.AddWrite(SYNCHRONOUS, |
| 3677 | ConstructClientAckAndConnectionClosePacket( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3678 | 3, quic::QuicTime::Delta::Zero(), 1, 1, 1, |
| 3679 | quic::QUIC_INVALID_STREAM_ID, quic_error_details)); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3680 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3681 | |
| 3682 | // After that fails, it will be resent via TCP. |
| 3683 | MockWrite http_writes[] = { |
| 3684 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3685 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3686 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3687 | |
| 3688 | MockRead http_reads[] = { |
| 3689 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3690 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3691 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3692 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3693 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3694 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3695 | |
| 3696 | // In order for a new QUIC session to be established via alternate-protocol |
| 3697 | // without racing an HTTP connection, we need the host resolution to happen |
| 3698 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3699 | // connection to the the server, in this test we require confirmation |
| 3700 | // before encrypting so the HTTP job will still start. |
| 3701 | host_resolver_.set_synchronous_mode(true); |
| 3702 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3703 | ""); |
| 3704 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 3705 | AddressList address; |
| 3706 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 3707 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 3708 | CompletionOnceCallback(), &request, |
| 3709 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3710 | EXPECT_THAT(rv, IsOk()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3711 | |
| 3712 | CreateSession(); |
| 3713 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3714 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3715 | |
| 3716 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3717 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3718 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3719 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3720 | |
| 3721 | // Pump the message loop to get the request started. |
| 3722 | base::RunLoop().RunUntilIdle(); |
| 3723 | // Explicitly confirm the handshake. |
| 3724 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3725 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 2f2991c | 2017-04-13 19:28:17 | [diff] [blame] | 3726 | |
| 3727 | // Run the QUIC session to completion. |
| 3728 | base::RunLoop().RunUntilIdle(); |
| 3729 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3730 | |
| 3731 | ExpectQuicAlternateProtocolMapping(); |
| 3732 | |
| 3733 | // Let the transaction proceed which will result in QUIC being marked |
| 3734 | // as broken and the request falling back to TCP. |
| 3735 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3736 | |
| 3737 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3738 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3739 | |
| 3740 | // Read the response body over TCP. |
| 3741 | CheckResponseData(&trans, "hello world"); |
| 3742 | ExpectBrokenAlternateProtocolMapping(); |
| 3743 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3744 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3745 | } |
| 3746 | |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3747 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3748 | // request is reset from, then QUIC will be marked as broken and the request |
| 3749 | // retried over TCP. |
| 3750 | TEST_P(QuicNetworkTransactionTest, ResetAfterHandshakeConfirmedThenBroken) { |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3751 | // The request will initially go out over QUIC. |
| 3752 | MockQuicData quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3753 | quic::QuicStreamOffset header_stream_offset = 0; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 3754 | spdy::SpdyPriority priority = |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3755 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 3756 | |
| 3757 | std::string request_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3758 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 3759 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3760 | quic_data.AddWrite(SYNCHRONOUS, |
| 3761 | client_maker_.MakeRequestHeadersPacketAndSaveData( |
| 3762 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 3763 | priority, GetRequestHeaders("GET", "https", "/"), 0, |
| 3764 | nullptr, &header_stream_offset, &request_data)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3765 | |
| 3766 | std::string settings_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3767 | // quic::QuicStreamOffset settings_offset = header_stream_offset; |
| 3768 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3769 | quic_data.AddWrite(SYNCHRONOUS, |
| 3770 | client_maker_.MakeInitialSettingsPacketAndSaveData( |
| 3771 | 2, &header_stream_offset, &settings_data)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3772 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3773 | quic_data.AddRead(ASYNC, ConstructServerRstPacket( |
| 3774 | 1, false, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3775 | quic::QUIC_HEADERS_TOO_LARGE)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3776 | |
| 3777 | quic_data.AddRead(ASYNC, OK); |
| 3778 | quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3779 | |
| 3780 | // After that fails, it will be resent via TCP. |
| 3781 | MockWrite http_writes[] = { |
| 3782 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3783 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
| 3784 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3785 | |
| 3786 | MockRead http_reads[] = { |
| 3787 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3788 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3789 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3790 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3791 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3792 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3793 | |
| 3794 | // In order for a new QUIC session to be established via alternate-protocol |
| 3795 | // without racing an HTTP connection, we need the host resolution to happen |
| 3796 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 3797 | // connection to the the server, in this test we require confirmation |
| 3798 | // before encrypting so the HTTP job will still start. |
| 3799 | host_resolver_.set_synchronous_mode(true); |
| 3800 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 3801 | ""); |
| 3802 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 3803 | AddressList address; |
| 3804 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 3805 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 3806 | CompletionOnceCallback(), &request, |
| 3807 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3808 | EXPECT_THAT(rv, IsOk()); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3809 | |
| 3810 | CreateSession(); |
| 3811 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 3812 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3813 | |
| 3814 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 3815 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 3816 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3817 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 3818 | |
| 3819 | // Pump the message loop to get the request started. |
| 3820 | base::RunLoop().RunUntilIdle(); |
| 3821 | // Explicitly confirm the handshake. |
| 3822 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3823 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3824 | |
| 3825 | // Run the QUIC session to completion. |
| 3826 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3827 | |
| 3828 | ExpectQuicAlternateProtocolMapping(); |
| 3829 | |
| 3830 | // Let the transaction proceed which will result in QUIC being marked |
| 3831 | // as broken and the request falling back to TCP. |
| 3832 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 3833 | |
| 3834 | ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
| 3835 | ASSERT_FALSE(http_data.AllReadDataConsumed()); |
| 3836 | |
| 3837 | // Read the response body over TCP. |
| 3838 | CheckResponseData(&trans, "hello world"); |
| 3839 | ExpectBrokenAlternateProtocolMapping(); |
| 3840 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
| 3841 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 3842 | } |
| 3843 | |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3844 | // Verify that when an origin has two alt-svc advertisements, one local and one |
| 3845 | // remote, that when the local is broken the request will go over QUIC via |
| 3846 | // the remote Alt-Svc. |
| 3847 | // This is a regression test for crbug/825646. |
| 3848 | TEST_P(QuicNetworkTransactionTest, RemoteAltSvcWorkingWhileLocalAltSvcBroken) { |
| 3849 | session_params_.quic_allow_remote_alt_svc = true; |
| 3850 | |
| 3851 | GURL origin1 = request_.url; // mail.example.org |
| 3852 | GURL origin2("https://www.example.org/"); |
| 3853 | ASSERT_NE(origin1.host(), origin2.host()); |
| 3854 | |
| 3855 | scoped_refptr<X509Certificate> cert( |
| 3856 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 3857 | ASSERT_TRUE(cert->VerifyNameMatch("www.example.org")); |
| 3858 | ASSERT_TRUE(cert->VerifyNameMatch("mail.example.org")); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3859 | |
| 3860 | ProofVerifyDetailsChromium verify_details; |
| 3861 | verify_details.cert_verify_result.verified_cert = cert; |
| 3862 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 3863 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 3864 | |
| 3865 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3866 | quic::QuicStreamOffset request_header_offset(0); |
| 3867 | quic::QuicStreamOffset response_header_offset(0); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3868 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3869 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
| 3870 | mock_quic_data.AddWrite( |
| 3871 | SYNCHRONOUS, |
| 3872 | ConstructClientRequestHeadersPacket( |
| 3873 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 3874 | GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
| 3875 | mock_quic_data.AddRead( |
| 3876 | ASYNC, ConstructServerResponseHeadersPacket( |
| 3877 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 3878 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 3879 | mock_quic_data.AddRead( |
| 3880 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 3881 | false, true, 0, "hello!")); |
| 3882 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3883 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 3884 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 3885 | |
| 3886 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3887 | MockQuicData mock_quic_data2; |
| 3888 | mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 3889 | AddHangingNonAlternateProtocolSocketData(); |
| 3890 | |
| 3891 | CreateSession(); |
| 3892 | |
| 3893 | // Set up alternative service for |origin1|. |
| 3894 | AlternativeService local_alternative(kProtoQUIC, "mail.example.org", 443); |
| 3895 | AlternativeService remote_alternative(kProtoQUIC, "www.example.org", 443); |
| 3896 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| 3897 | AlternativeServiceInfoVector alternative_services; |
| 3898 | alternative_services.push_back( |
| 3899 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 3900 | local_alternative, expiration, |
| 3901 | session_->params().quic_supported_versions)); |
| 3902 | alternative_services.push_back( |
| 3903 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 3904 | remote_alternative, expiration, |
| 3905 | session_->params().quic_supported_versions)); |
| 3906 | http_server_properties_.SetAlternativeServices(url::SchemeHostPort(origin1), |
| 3907 | alternative_services); |
| 3908 | |
| 3909 | http_server_properties_.MarkAlternativeServiceBroken(local_alternative); |
| 3910 | |
| 3911 | SendRequestAndExpectQuicResponse("hello!"); |
| 3912 | } |
| 3913 | |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3914 | // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC |
| 3915 | // request is reset from, then QUIC will be marked as broken and the request |
| 3916 | // retried over TCP. Then, subsequent requests will go over a new QUIC |
| 3917 | // connection instead of going back to the broken QUIC connection. |
| 3918 | // This is a regression tests for crbug/731303. |
| 3919 | TEST_P(QuicNetworkTransactionTest, |
| 3920 | ResetPooledAfterHandshakeConfirmedThenBroken) { |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 3921 | session_params_.quic_allow_remote_alt_svc = true; |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3922 | |
| 3923 | GURL origin1 = request_.url; |
| 3924 | GURL origin2("https://www.example.org/"); |
| 3925 | ASSERT_NE(origin1.host(), origin2.host()); |
| 3926 | |
| 3927 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3928 | quic::QuicStreamOffset request_header_offset(0); |
| 3929 | quic::QuicStreamOffset response_header_offset(0); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3930 | |
| 3931 | scoped_refptr<X509Certificate> cert( |
| 3932 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 3933 | ASSERT_TRUE(cert->VerifyNameMatch("www.example.org")); |
| 3934 | ASSERT_TRUE(cert->VerifyNameMatch("mail.example.org")); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3935 | |
| 3936 | ProofVerifyDetailsChromium verify_details; |
| 3937 | verify_details.cert_verify_result.verified_cert = cert; |
| 3938 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 3939 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 3940 | |
| 3941 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3942 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3943 | // First request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3944 | mock_quic_data.AddWrite( |
| 3945 | SYNCHRONOUS, |
| 3946 | ConstructClientRequestHeadersPacket( |
| 3947 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 3948 | GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
| 3949 | mock_quic_data.AddRead( |
| 3950 | ASYNC, ConstructServerResponseHeadersPacket( |
| 3951 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 3952 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 3953 | mock_quic_data.AddRead( |
| 3954 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 3955 | false, true, 0, "hello!")); |
| 3956 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3957 | |
| 3958 | // Second request will go over the pooled QUIC connection, but will be |
| 3959 | // reset by the server. |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 3960 | QuicTestPacketMaker client_maker2( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3961 | version_, 0, &clock_, origin2.host(), quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 3962 | client_headers_include_h2_stream_dependency_); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3963 | QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2.host(), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3964 | quic::Perspective::IS_SERVER, false); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 3965 | mock_quic_data.AddWrite( |
| 3966 | SYNCHRONOUS, |
| 3967 | ConstructClientRequestHeadersPacket( |
| 3968 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 3969 | GetRequestHeaders("GET", "https", "/", &client_maker2), |
| 3970 | GetNthClientInitiatedStreamId(0), &request_header_offset)); |
| 3971 | mock_quic_data.AddRead(ASYNC, ConstructServerRstPacket( |
| 3972 | 3, false, GetNthClientInitiatedStreamId(1), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 3973 | quic::QUIC_HEADERS_TOO_LARGE)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3974 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 3975 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 3976 | |
| 3977 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 3978 | |
| 3979 | // After that fails, it will be resent via TCP. |
| 3980 | MockWrite http_writes[] = { |
| 3981 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
| 3982 | MockWrite(SYNCHRONOUS, 1, "Host: www.example.org\r\n"), |
| 3983 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
| 3984 | |
| 3985 | MockRead http_reads[] = { |
| 3986 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
| 3987 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
| 3988 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 3989 | SequencedSocketData http_data(http_reads, http_writes); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3990 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3991 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 3992 | |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 3993 | // Then the next request to the second origin will be sent over TCP. |
| 3994 | socket_factory_.AddSocketDataProvider(&http_data); |
| 3995 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 3996 | |
| 3997 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 3998 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 3999 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4000 | session_->quic_stream_factory(), |
| 4001 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4002 | &clock_)); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 4003 | |
| 4004 | // Set up alternative service for |origin1|. |
| 4005 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 4006 | AlternativeService alternative1(kProtoQUIC, origin1.host(), 443); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4007 | http_server_properties_.SetQuicAlternativeService( |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 4008 | url::SchemeHostPort(origin1), alternative1, expiration, |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 4009 | supported_versions_); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 4010 | |
| 4011 | // Set up alternative service for |origin2|. |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 4012 | AlternativeService alternative2(kProtoQUIC, origin2.host(), 443); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4013 | http_server_properties_.SetQuicAlternativeService( |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 4014 | url::SchemeHostPort(origin2), alternative2, expiration, |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 4015 | supported_versions_); |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 4016 | |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 4017 | // First request opens connection to |destination1| |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4018 | // with quic::QuicServerId.host() == origin1.host(). |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 4019 | SendRequestAndExpectQuicResponse("hello!"); |
| 4020 | |
| 4021 | // Second request pools to existing connection with same destination, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4022 | // because certificate matches, even though quic::QuicServerId is different. |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 4023 | // After it is reset, it will fail back to QUIC and mark QUIC as broken. |
| 4024 | request_.url = origin2; |
| 4025 | SendRequestAndExpectHttpResponse("hello world"); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 4026 | EXPECT_FALSE(http_server_properties_.IsAlternativeServiceBroken(alternative1)) |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 4027 | << alternative1.ToString(); |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 4028 | EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(alternative2)) |
Ryan Hamilton | cec1cee8 | 2017-12-15 00:00:24 | [diff] [blame] | 4029 | << alternative2.ToString(); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 4030 | |
| 4031 | // The third request should use a new QUIC connection, not the broken |
| 4032 | // QUIC connection. |
Ryan Hamilton | 6c2a2a8 | 2017-12-15 02:06:28 | [diff] [blame] | 4033 | SendRequestAndExpectHttpResponse("hello world"); |
rch | 30943ee | 2017-06-12 21:28:44 | [diff] [blame] | 4034 | } |
| 4035 | |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 4036 | TEST_P(QuicNetworkTransactionTest, |
| 4037 | DoNotUseAlternativeServiceQuicUnsupportedVersion) { |
| 4038 | std::string altsvc_header = base::StringPrintf( |
bnc | 90be5dd78 | 2016-11-09 16:28:44 | [diff] [blame] | 4039 | "Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_ - 1); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 4040 | MockRead http_reads[] = { |
| 4041 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()), |
| 4042 | MockRead("hello world"), |
| 4043 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4044 | MockRead(ASYNC, OK)}; |
| 4045 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4046 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 4047 | socket_factory_.AddSocketDataProvider(&http_data); |
| 4048 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 4049 | socket_factory_.AddSocketDataProvider(&http_data); |
| 4050 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 4051 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4052 | CreateSession(); |
bnc | 8be55ebb | 2015-10-30 14:12:07 | [diff] [blame] | 4053 | |
| 4054 | SendRequestAndExpectHttpResponse("hello world"); |
| 4055 | SendRequestAndExpectHttpResponse("hello world"); |
| 4056 | } |
| 4057 | |
Xida Chen | 9bfe0b6 | 2018-04-24 19:52:21 | [diff] [blame] | 4058 | // When multiple alternative services are advertised, HttpStreamFactory should |
| 4059 | // select the alternative service which uses existing QUIC session if available. |
| 4060 | // If no existing QUIC session can be used, use the first alternative service |
| 4061 | // from the list. |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4062 | TEST_P(QuicNetworkTransactionTest, UseExistingAlternativeServiceForQuic) { |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 4063 | session_params_.quic_allow_remote_alt_svc = true; |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4064 | MockRead http_reads[] = { |
| 4065 | MockRead("HTTP/1.1 200 OK\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4066 | MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4067 | MockRead("hello world"), |
| 4068 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4069 | MockRead(ASYNC, OK)}; |
| 4070 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4071 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4072 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4073 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4074 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4075 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4076 | quic::QuicStreamOffset request_header_offset = 0; |
| 4077 | quic::QuicStreamOffset response_header_offset = 0; |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4078 | // First QUIC request data. |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4079 | // Open a session to foo.example.org:443 using the first entry of the |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4080 | // alternative service list. |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4081 | MockQuicData mock_quic_data; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4082 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4083 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
| 4084 | mock_quic_data.AddWrite( |
| 4085 | SYNCHRONOUS, |
| 4086 | ConstructClientRequestHeadersPacket( |
| 4087 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4088 | GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4089 | |
| 4090 | std::string alt_svc_list = |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4091 | "quic=\"mail.example.org:444\", quic=\"foo.example.org:443\", " |
| 4092 | "quic=\"bar.example.org:445\""; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4093 | mock_quic_data.AddRead( |
| 4094 | ASYNC, |
| 4095 | ConstructServerResponseHeadersPacket( |
| 4096 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 4097 | GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset)); |
| 4098 | mock_quic_data.AddRead( |
| 4099 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4100 | false, true, 0, "hello!")); |
| 4101 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4102 | |
| 4103 | // Second QUIC request data. |
| 4104 | // Connection pooling, using existing session, no need to include version |
| 4105 | // as version negotiation has been completed. |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4106 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4107 | SYNCHRONOUS, |
| 4108 | ConstructClientRequestHeadersPacket( |
| 4109 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 4110 | GetRequestHeaders("GET", "https", "/"), |
| 4111 | GetNthClientInitiatedStreamId(0), &request_header_offset)); |
| 4112 | mock_quic_data.AddRead( |
| 4113 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4114 | 3, GetNthClientInitiatedStreamId(1), false, false, |
| 4115 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4116 | mock_quic_data.AddRead( |
| 4117 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(1), |
| 4118 | false, true, 0, "hello!")); |
| 4119 | mock_quic_data.AddWrite( |
| 4120 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4121 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4122 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4123 | |
| 4124 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4125 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4126 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4127 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 4128 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 4129 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4130 | session_->quic_stream_factory(), |
| 4131 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4132 | &clock_)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4133 | |
| 4134 | SendRequestAndExpectHttpResponse("hello world"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4135 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4136 | SendRequestAndExpectQuicResponse("hello!"); |
| 4137 | SendRequestAndExpectQuicResponse("hello!"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4138 | } |
| 4139 | |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4140 | // Check that an existing QUIC connection to an alternative proxy server is |
| 4141 | // used. |
| 4142 | TEST_P(QuicNetworkTransactionTest, UseExistingQUICAlternativeProxy) { |
| 4143 | base::HistogramTester histogram_tester; |
| 4144 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4145 | quic::QuicStreamOffset request_header_offset = 0; |
| 4146 | quic::QuicStreamOffset response_header_offset = 0; |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4147 | // First QUIC request data. |
| 4148 | // Open a session to foo.example.org:443 using the first entry of the |
| 4149 | // alternative service list. |
| 4150 | MockQuicData mock_quic_data; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4151 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4152 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
| 4153 | mock_quic_data.AddWrite( |
| 4154 | SYNCHRONOUS, |
| 4155 | ConstructClientRequestHeadersPacket( |
| 4156 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4157 | GetRequestHeaders("GET", "http", "/"), &request_header_offset)); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4158 | |
| 4159 | std::string alt_svc_list; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4160 | mock_quic_data.AddRead( |
| 4161 | ASYNC, |
| 4162 | ConstructServerResponseHeadersPacket( |
| 4163 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 4164 | GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset)); |
| 4165 | mock_quic_data.AddRead( |
| 4166 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4167 | false, true, 0, "hello!")); |
| 4168 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4169 | |
| 4170 | // Second QUIC request data. |
| 4171 | // Connection pooling, using existing session, no need to include version |
| 4172 | // as version negotiation has been completed. |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4173 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4174 | SYNCHRONOUS, |
| 4175 | ConstructClientRequestHeadersPacket( |
| 4176 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 4177 | GetRequestHeaders("GET", "http", "/"), |
| 4178 | GetNthClientInitiatedStreamId(0), &request_header_offset)); |
| 4179 | mock_quic_data.AddRead( |
| 4180 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4181 | 3, GetNthClientInitiatedStreamId(1), false, false, |
| 4182 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4183 | mock_quic_data.AddRead( |
| 4184 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(1), |
| 4185 | false, true, 0, "hello!")); |
| 4186 | mock_quic_data.AddWrite( |
| 4187 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4188 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4189 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4190 | |
| 4191 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4192 | |
| 4193 | AddHangingNonAlternateProtocolSocketData(); |
| 4194 | |
| 4195 | TestProxyDelegate test_proxy_delegate; |
| 4196 | |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 4197 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 4198 | "HTTPS mail.example.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4199 | |
| 4200 | test_proxy_delegate.set_alternative_proxy_server( |
| 4201 | ProxyServer::FromPacString("QUIC mail.example.org:443")); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 4202 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4203 | |
| 4204 | request_.url = GURL("http://mail.example.org/"); |
| 4205 | |
| 4206 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 4207 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 4208 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4209 | session_->quic_stream_factory(), |
| 4210 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4211 | &clock_)); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4212 | |
| 4213 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443); |
| 4214 | histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage", |
| 4215 | 1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */, |
| 4216 | 1); |
| 4217 | |
| 4218 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443); |
| 4219 | histogram_tester.ExpectTotalCount("Net.QuicAlternativeProxy.Usage", 2); |
| 4220 | histogram_tester.ExpectBucketCount("Net.QuicAlternativeProxy.Usage", |
| 4221 | 0 /* ALTERNATIVE_PROXY_USAGE_NO_RACE */, |
| 4222 | 1); |
| 4223 | } |
| 4224 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4225 | // Pool to existing session with matching quic::QuicServerId |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4226 | // even if alternative service destination is different. |
| 4227 | TEST_P(QuicNetworkTransactionTest, PoolByOrigin) { |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 4228 | session_params_.quic_allow_remote_alt_svc = true; |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4229 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4230 | quic::QuicStreamOffset request_header_offset(0); |
| 4231 | quic::QuicStreamOffset response_header_offset(0); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4232 | |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4233 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4234 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4235 | // First request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4236 | mock_quic_data.AddWrite( |
| 4237 | SYNCHRONOUS, |
| 4238 | ConstructClientRequestHeadersPacket( |
| 4239 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4240 | GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
| 4241 | mock_quic_data.AddRead( |
| 4242 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4243 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 4244 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4245 | mock_quic_data.AddRead( |
| 4246 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4247 | false, true, 0, "hello!")); |
| 4248 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4249 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4250 | // Second request. |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4251 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4252 | SYNCHRONOUS, |
| 4253 | ConstructClientRequestHeadersPacket( |
| 4254 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 4255 | GetRequestHeaders("GET", "https", "/"), |
| 4256 | GetNthClientInitiatedStreamId(0), &request_header_offset)); |
| 4257 | mock_quic_data.AddRead( |
| 4258 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4259 | 3, GetNthClientInitiatedStreamId(1), false, false, |
| 4260 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4261 | mock_quic_data.AddRead( |
| 4262 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(1), |
| 4263 | false, true, 0, "hello!")); |
| 4264 | mock_quic_data.AddWrite( |
| 4265 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4266 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4267 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4268 | |
| 4269 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4270 | |
| 4271 | AddHangingNonAlternateProtocolSocketData(); |
| 4272 | AddHangingNonAlternateProtocolSocketData(); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4273 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4274 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 4275 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 4276 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4277 | session_->quic_stream_factory(), |
| 4278 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4279 | &clock_)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4280 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4281 | const char destination1[] = "first.example.com"; |
| 4282 | const char destination2[] = "second.example.com"; |
| 4283 | |
| 4284 | // Set up alternative service entry to destination1. |
| 4285 | url::SchemeHostPort server(request_.url); |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4286 | AlternativeService alternative_service(kProtoQUIC, destination1, 443); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4287 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4288 | http_server_properties_.SetQuicAlternativeService( |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 4289 | server, alternative_service, expiration, supported_versions_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4290 | // First request opens connection to |destination1| |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4291 | // with quic::QuicServerId.host() == kDefaultServerHostName. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4292 | SendRequestAndExpectQuicResponse("hello!"); |
| 4293 | |
| 4294 | // Set up alternative service entry to a different destination. |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4295 | alternative_service = AlternativeService(kProtoQUIC, destination2, 443); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4296 | http_server_properties_.SetQuicAlternativeService( |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 4297 | server, alternative_service, expiration, supported_versions_); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4298 | // Second request pools to existing connection with same quic::QuicServerId, |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4299 | // even though alternative service destination is different. |
| 4300 | SendRequestAndExpectQuicResponse("hello!"); |
| 4301 | } |
| 4302 | |
| 4303 | // Pool to existing session with matching destination and matching certificate |
| 4304 | // even if origin is different, and even if the alternative service with |
| 4305 | // matching destination is not the first one on the list. |
| 4306 | TEST_P(QuicNetworkTransactionTest, PoolByDestination) { |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 4307 | session_params_.quic_allow_remote_alt_svc = true; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4308 | GURL origin1 = request_.url; |
| 4309 | GURL origin2("https://www.example.org/"); |
| 4310 | ASSERT_NE(origin1.host(), origin2.host()); |
| 4311 | |
| 4312 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4313 | quic::QuicStreamOffset request_header_offset(0); |
| 4314 | quic::QuicStreamOffset response_header_offset(0); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4315 | |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4316 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4317 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4318 | // First request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4319 | mock_quic_data.AddWrite( |
| 4320 | SYNCHRONOUS, |
| 4321 | ConstructClientRequestHeadersPacket( |
| 4322 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4323 | GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
| 4324 | mock_quic_data.AddRead( |
| 4325 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4326 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 4327 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4328 | mock_quic_data.AddRead( |
| 4329 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4330 | false, true, 0, "hello!")); |
| 4331 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4332 | |
| 4333 | // Second request. |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 4334 | QuicTestPacketMaker client_maker2( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4335 | version_, 0, &clock_, origin2.host(), quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 4336 | client_headers_include_h2_stream_dependency_); |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 4337 | QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2.host(), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4338 | quic::Perspective::IS_SERVER, false); |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4339 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4340 | SYNCHRONOUS, |
| 4341 | ConstructClientRequestHeadersPacket( |
| 4342 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 4343 | GetRequestHeaders("GET", "https", "/", &client_maker2), |
| 4344 | GetNthClientInitiatedStreamId(0), &request_header_offset)); |
| 4345 | mock_quic_data.AddRead( |
| 4346 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4347 | 3, GetNthClientInitiatedStreamId(1), false, false, |
| 4348 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4349 | mock_quic_data.AddRead( |
| 4350 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(1), |
| 4351 | false, true, 0, "hello!")); |
| 4352 | mock_quic_data.AddWrite( |
| 4353 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4354 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4355 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4356 | |
| 4357 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4358 | |
| 4359 | AddHangingNonAlternateProtocolSocketData(); |
| 4360 | AddHangingNonAlternateProtocolSocketData(); |
| 4361 | |
| 4362 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 4363 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 4364 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4365 | session_->quic_stream_factory(), |
| 4366 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4367 | &clock_)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4368 | |
| 4369 | const char destination1[] = "first.example.com"; |
| 4370 | const char destination2[] = "second.example.com"; |
| 4371 | |
| 4372 | // Set up alternative service for |origin1|. |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4373 | AlternativeService alternative_service1(kProtoQUIC, destination1, 443); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4374 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4375 | http_server_properties_.SetQuicAlternativeService( |
| 4376 | url::SchemeHostPort(origin1), alternative_service1, expiration, |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 4377 | supported_versions_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4378 | |
| 4379 | // Set up multiple alternative service entries for |origin2|, |
| 4380 | // the first one with a different destination as for |origin1|, |
| 4381 | // the second one with the same. The second one should be used, |
| 4382 | // because the request can be pooled to that one. |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4383 | AlternativeService alternative_service2(kProtoQUIC, destination2, 443); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4384 | AlternativeServiceInfoVector alternative_services; |
| 4385 | alternative_services.push_back( |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4386 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 4387 | alternative_service2, expiration, |
| 4388 | session_->params().quic_supported_versions)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4389 | alternative_services.push_back( |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 4390 | AlternativeServiceInfo::CreateQuicAlternativeServiceInfo( |
| 4391 | alternative_service1, expiration, |
| 4392 | session_->params().quic_supported_versions)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4393 | http_server_properties_.SetAlternativeServices(url::SchemeHostPort(origin2), |
| 4394 | alternative_services); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4395 | // First request opens connection to |destination1| |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4396 | // with quic::QuicServerId.host() == origin1.host(). |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4397 | SendRequestAndExpectQuicResponse("hello!"); |
| 4398 | |
| 4399 | // Second request pools to existing connection with same destination, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4400 | // because certificate matches, even though quic::QuicServerId is different. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4401 | request_.url = origin2; |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4402 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4403 | SendRequestAndExpectQuicResponse("hello!"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4404 | } |
| 4405 | |
| 4406 | // Multiple origins have listed the same alternative services. When there's a |
| 4407 | // existing QUIC session opened by a request to other origin, |
| 4408 | // if the cert is valid, should select this QUIC session to make the request |
| 4409 | // if this is also the first existing QUIC session. |
| 4410 | TEST_P(QuicNetworkTransactionTest, |
| 4411 | UseSharedExistingAlternativeServiceForQuicWithValidCert) { |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 4412 | session_params_.quic_allow_remote_alt_svc = true; |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4413 | // Default cert is valid for *.example.org |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4414 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4415 | // HTTP data for request to www.example.org. |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4416 | MockRead http_reads[] = { |
| 4417 | MockRead("HTTP/1.1 200 OK\r\n"), |
| 4418 | MockRead("Alt-Svc: quic=\":443\"\r\n\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4419 | MockRead("hello world from www.example.org"), |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4420 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4421 | MockRead(ASYNC, OK)}; |
| 4422 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4423 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4424 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4425 | AddCertificate(&ssl_data_); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4426 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 4427 | |
| 4428 | // HTTP data for request to mail.example.org. |
| 4429 | MockRead http_reads2[] = { |
| 4430 | MockRead("HTTP/1.1 200 OK\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4431 | MockRead("Alt-Svc: quic=\":444\", quic=\"www.example.org:443\"\r\n\r\n"), |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4432 | MockRead("hello world from mail.example.org"), |
| 4433 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4434 | MockRead(ASYNC, OK)}; |
| 4435 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4436 | StaticSocketDataProvider http_data2(http_reads2, base::span<MockWrite>()); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4437 | socket_factory_.AddSocketDataProvider(&http_data2); |
| 4438 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 4439 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4440 | quic::QuicStreamOffset request_header_offset = 0; |
| 4441 | quic::QuicStreamOffset response_header_offset = 0; |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4442 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 4443 | QuicTestPacketMaker client_maker( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4444 | version_, 0, &clock_, "mail.example.org", quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 4445 | client_headers_include_h2_stream_dependency_); |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4446 | server_maker_.set_hostname("www.example.org"); |
| 4447 | client_maker_.set_hostname("www.example.org"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4448 | MockQuicData mock_quic_data; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4449 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4450 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &request_header_offset)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4451 | // First QUIC request data. |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 4452 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4453 | SYNCHRONOUS, |
| 4454 | ConstructClientRequestHeadersPacket( |
| 4455 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4456 | GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
| 4457 | |
| 4458 | mock_quic_data.AddRead( |
| 4459 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4460 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 4461 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4462 | mock_quic_data.AddRead(ASYNC, ConstructServerDataPacket( |
| 4463 | 2, GetNthClientInitiatedStreamId(0), false, |
| 4464 | true, 0, "hello from mail QUIC!")); |
| 4465 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
| 4466 | // Second QUIC request data. |
| 4467 | mock_quic_data.AddWrite( |
| 4468 | SYNCHRONOUS, |
| 4469 | ConstructClientRequestHeadersPacket( |
| 4470 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 4471 | GetRequestHeaders("GET", "https", "/", &client_maker), |
| 4472 | GetNthClientInitiatedStreamId(0), &request_header_offset)); |
| 4473 | mock_quic_data.AddRead( |
| 4474 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4475 | 3, GetNthClientInitiatedStreamId(1), false, false, |
| 4476 | GetResponseHeaders("200 OK"), &response_header_offset)); |
| 4477 | mock_quic_data.AddRead(ASYNC, ConstructServerDataPacket( |
| 4478 | 4, GetNthClientInitiatedStreamId(1), false, |
| 4479 | true, 0, "hello from mail QUIC!")); |
| 4480 | mock_quic_data.AddWrite( |
| 4481 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4482 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4483 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4484 | |
| 4485 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4486 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4487 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4488 | CreateSession(); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 4489 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 4490 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4491 | session_->quic_stream_factory(), |
| 4492 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4493 | &clock_)); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4494 | |
| 4495 | // Send two HTTP requests, responses set up alt-svc lists for the origins. |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4496 | request_.url = GURL("https://www.example.org/"); |
| 4497 | SendRequestAndExpectHttpResponse("hello world from www.example.org"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4498 | request_.url = GURL("https://mail.example.org/"); |
| 4499 | SendRequestAndExpectHttpResponse("hello world from mail.example.org"); |
| 4500 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4501 | // Open a QUIC session to mail.example.org:443 when making request |
| 4502 | // to mail.example.org. |
| 4503 | request_.url = GURL("https://www.example.org/"); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4504 | SendRequestAndExpectQuicResponse("hello from mail QUIC!"); |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4505 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4506 | // Uses the existing QUIC session when making request to www.example.org. |
zhongyi | 32569c6 | 2016-01-08 02:54:30 | [diff] [blame] | 4507 | request_.url = GURL("https://mail.example.org/"); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4508 | SendRequestAndExpectQuicResponse("hello from mail QUIC!"); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4509 | } |
| 4510 | |
| 4511 | TEST_P(QuicNetworkTransactionTest, AlternativeServiceDifferentPort) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4512 | MockRead http_reads[] = { |
| 4513 | MockRead("HTTP/1.1 200 OK\r\n"), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4514 | MockRead(kQuicAlternativeServiceDifferentPortHeader), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4515 | MockRead("hello world"), |
| 4516 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4517 | MockRead(ASYNC, OK)}; |
| 4518 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4519 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4520 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4521 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4522 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4523 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4524 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4525 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4526 | |
| 4527 | SendRequestAndExpectHttpResponse("hello world"); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 4528 | |
| 4529 | url::SchemeHostPort http_server("https", kDefaultServerHostName, 443); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 4530 | AlternativeServiceInfoVector alternative_service_info_vector = |
| 4531 | http_server_properties_.GetAlternativeServiceInfos(http_server); |
| 4532 | ASSERT_EQ(1u, alternative_service_info_vector.size()); |
| 4533 | const AlternativeService alternative_service = |
zhongyi | 422ce35 | 2017-06-09 23:28:54 | [diff] [blame] | 4534 | alternative_service_info_vector[0].alternative_service(); |
zhongyi | c4de0303 | 2017-05-19 04:07:34 | [diff] [blame] | 4535 | EXPECT_EQ(kProtoQUIC, alternative_service.protocol); |
| 4536 | EXPECT_EQ(kDefaultServerHostName, alternative_service.host); |
| 4537 | EXPECT_EQ(137, alternative_service.port); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4538 | } |
| 4539 | |
| 4540 | TEST_P(QuicNetworkTransactionTest, ConfirmAlternativeService) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4541 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4542 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 4543 | MockRead("hello world"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4544 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4545 | MockRead(ASYNC, OK)}; |
| 4546 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4547 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4548 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4549 | AddCertificate(&ssl_data_); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4550 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4551 | |
| 4552 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4553 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4554 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4555 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 4556 | mock_quic_data.AddWrite( |
| 4557 | SYNCHRONOUS, |
| 4558 | ConstructClientRequestHeadersPacket( |
| 4559 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4560 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 4561 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 4562 | 1, GetNthClientInitiatedStreamId(0), false, |
| 4563 | false, GetResponseHeaders("200 OK"))); |
| 4564 | mock_quic_data.AddRead( |
| 4565 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4566 | false, true, 0, "hello!")); |
| 4567 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4568 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4569 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4570 | |
| 4571 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4572 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4573 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4574 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4575 | |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 4576 | AlternativeService alternative_service(kProtoQUIC, |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4577 | HostPortPair::FromURL(request_.url)); |
| 4578 | http_server_properties_.MarkAlternativeServiceRecentlyBroken( |
| 4579 | alternative_service); |
| 4580 | EXPECT_TRUE(http_server_properties_.WasAlternativeServiceRecentlyBroken( |
| 4581 | alternative_service)); |
| 4582 | |
| 4583 | SendRequestAndExpectHttpResponse("hello world"); |
| 4584 | SendRequestAndExpectQuicResponse("hello!"); |
| 4585 | |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4586 | mock_quic_data.Resume(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4587 | |
| 4588 | EXPECT_FALSE(http_server_properties_.WasAlternativeServiceRecentlyBroken( |
| 4589 | alternative_service)); |
rch | ac7f35e | 2017-03-15 20:42:30 | [diff] [blame] | 4590 | EXPECT_NE(nullptr, |
| 4591 | http_server_properties_.GetServerNetworkStats( |
| 4592 | url::SchemeHostPort("https", request_.url.host(), 443))); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4593 | } |
| 4594 | |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4595 | TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuicForHttps) { |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4596 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4597 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 4598 | MockRead("hello world"), |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4599 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 4600 | MockRead(ASYNC, OK)}; |
| 4601 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4602 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4603 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4604 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4605 | |
| 4606 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4607 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4608 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4609 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 4610 | mock_quic_data.AddWrite( |
| 4611 | SYNCHRONOUS, |
| 4612 | ConstructClientRequestHeadersPacket( |
| 4613 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4614 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 4615 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 4616 | 1, GetNthClientInitiatedStreamId(0), false, |
| 4617 | false, GetResponseHeaders("200 OK"))); |
| 4618 | mock_quic_data.AddRead( |
| 4619 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4620 | false, true, 0, "hello!")); |
| 4621 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4622 | mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF |
| 4623 | |
| 4624 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4625 | |
| 4626 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4627 | CreateSession(); |
bnc | c958faa | 2015-07-31 18:14:52 | [diff] [blame] | 4628 | |
| 4629 | // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo(). |
| 4630 | SendRequestAndExpectHttpResponse("hello world"); |
| 4631 | } |
| 4632 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4633 | // Tests that the connection to an HTTPS proxy is raced with an available |
| 4634 | // alternative proxy server. |
| 4635 | TEST_P(QuicNetworkTransactionTest, QuicProxyWithRacing) { |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4636 | base::HistogramTester histogram_tester; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 4637 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 4638 | "HTTPS mail.example.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4639 | |
| 4640 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4641 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4642 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4643 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 4644 | mock_quic_data.AddWrite( |
| 4645 | SYNCHRONOUS, |
| 4646 | ConstructClientRequestHeadersPacket( |
| 4647 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4648 | GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
| 4649 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 4650 | 1, GetNthClientInitiatedStreamId(0), false, |
| 4651 | false, GetResponseHeaders("200 OK"))); |
| 4652 | mock_quic_data.AddRead( |
| 4653 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4654 | false, true, 0, "hello!")); |
| 4655 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4656 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4657 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4658 | |
| 4659 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4660 | |
| 4661 | // There is no need to set up main job, because no attempt will be made to |
| 4662 | // speak to the proxy over TCP. |
| 4663 | request_.url = GURL("http://mail.example.org/"); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4664 | TestProxyDelegate test_proxy_delegate; |
| 4665 | const HostPortPair host_port_pair("mail.example.org", 443); |
| 4666 | |
| 4667 | test_proxy_delegate.set_alternative_proxy_server( |
| 4668 | ProxyServer::FromPacString("QUIC mail.example.org:443")); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 4669 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4670 | CreateSession(); |
| 4671 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 4672 | |
| 4673 | // The main job needs to hang in order to guarantee that the alternative |
| 4674 | // proxy server job will "win". |
| 4675 | AddHangingNonAlternateProtocolSocketData(); |
| 4676 | |
| 4677 | SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443); |
| 4678 | |
| 4679 | // Verify that the alternative proxy server is not marked as broken. |
| 4680 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 4681 | |
| 4682 | // Verify that the proxy server is not marked as broken. |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 4683 | EXPECT_TRUE(session_->proxy_resolution_service()->proxy_retry_info().empty()); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 4684 | |
| 4685 | histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage", |
| 4686 | 1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */, |
| 4687 | 1); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 4688 | } |
| 4689 | |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 4690 | TEST_P(QuicNetworkTransactionTest, HungAlternativeService) { |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4691 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4692 | MockCryptoClientStream::COLD_START); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4693 | |
| 4694 | MockWrite http_writes[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4695 | MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"), |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4696 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4697 | MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")}; |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4698 | |
| 4699 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4700 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 4701 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4702 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4703 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4704 | SequencedSocketData http_data(http_reads, http_writes); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4705 | socket_factory_.AddSocketDataProvider(&http_data); |
Bence Béky | 230ac61 | 2017-08-30 19:17:08 | [diff] [blame] | 4706 | AddCertificate(&ssl_data_); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4707 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4708 | |
| 4709 | // The QUIC transaction will not be allowed to complete. |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4710 | MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 1)}; |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4711 | MockRead quic_reads[] = { |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4712 | MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0), |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4713 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4714 | SequencedSocketData quic_data(quic_reads, quic_writes); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4715 | socket_factory_.AddSocketDataProvider(&quic_data); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4716 | |
| 4717 | // The HTTP transaction will complete. |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4718 | SequencedSocketData http_data2(http_reads, http_writes); |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4719 | socket_factory_.AddSocketDataProvider(&http_data2); |
| 4720 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4721 | |
bnc | 912a04b | 2016-04-20 14:19:50 | [diff] [blame] | 4722 | CreateSession(); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4723 | |
| 4724 | // Run the first request. |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4725 | SendRequestAndExpectHttpResponse("hello world"); |
rch | 37de576c | 2015-05-17 20:28:17 | [diff] [blame] | 4726 | ASSERT_TRUE(http_data.AllReadDataConsumed()); |
| 4727 | ASSERT_TRUE(http_data.AllWriteDataConsumed()); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4728 | |
| 4729 | // Now run the second request in which the QUIC socket hangs, |
| 4730 | // and verify the the transaction continues over HTTP. |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4731 | SendRequestAndExpectHttpResponse("hello world"); |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4732 | base::RunLoop().RunUntilIdle(); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4733 | |
rch | 37de576c | 2015-05-17 20:28:17 | [diff] [blame] | 4734 | ASSERT_TRUE(http_data2.AllReadDataConsumed()); |
| 4735 | ASSERT_TRUE(http_data2.AllWriteDataConsumed()); |
mmenke | 651bae7f | 2015-12-18 21:26:45 | [diff] [blame] | 4736 | ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
[email protected] | dda75ab | 2013-06-22 22:43:30 | [diff] [blame] | 4737 | } |
| 4738 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4739 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) { |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4740 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4741 | quic::QuicStreamOffset header_stream_offset = 0; |
| 4742 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 4743 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4744 | mock_quic_data.AddWrite( |
| 4745 | SYNCHRONOUS, |
| 4746 | ConstructClientRequestHeadersPacket( |
| 4747 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 4748 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 4749 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 4750 | 1, GetNthClientInitiatedStreamId(0), false, |
| 4751 | false, GetResponseHeaders("200 OK"))); |
| 4752 | mock_quic_data.AddRead( |
| 4753 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4754 | false, true, 0, "hello!")); |
| 4755 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 4756 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4757 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
[email protected] | 8ba8121 | 2013-05-03 13:11:48 | [diff] [blame] | 4758 | |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 4759 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 8ba8121 | 2013-05-03 13:11:48 | [diff] [blame] | 4760 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4761 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4762 | // the alternate-protocol job will "win". |
| 4763 | AddHangingNonAlternateProtocolSocketData(); |
| 4764 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4765 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4766 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 4767 | SendRequestAndExpectQuicResponse("hello!"); |
rch | ac7f35e | 2017-03-15 20:42:30 | [diff] [blame] | 4768 | |
| 4769 | EXPECT_EQ(nullptr, |
| 4770 | http_server_properties_.GetServerNetworkStats( |
| 4771 | url::SchemeHostPort("https", request_.url.host(), 443))); |
[email protected] | 8ba8121 | 2013-05-03 13:11:48 | [diff] [blame] | 4772 | } |
| 4773 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4774 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) { |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4775 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4776 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 4777 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4778 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4779 | ConstructClientRequestHeadersPacket( |
| 4780 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 4781 | GetRequestHeaders("GET", "https", "/"))); |
| 4782 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 4783 | 1, GetNthClientInitiatedStreamId(0), false, |
| 4784 | false, GetResponseHeaders("200 OK"))); |
| 4785 | mock_quic_data.AddRead( |
| 4786 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4787 | false, true, 0, "hello!")); |
| 4788 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 4789 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4790 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 4791 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 3a120a6b | 2013-06-25 01:08:27 | [diff] [blame] | 4792 | |
| 4793 | // In order for a new QUIC session to be established via alternate-protocol |
| 4794 | // without racing an HTTP connection, we need the host resolution to happen |
| 4795 | // synchronously. |
| 4796 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4797 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4798 | ""); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4799 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
[email protected] | 3a120a6b | 2013-06-25 01:08:27 | [diff] [blame] | 4800 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 4801 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 4802 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 4803 | CompletionOnceCallback(), &request, |
| 4804 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 4805 | EXPECT_THAT(rv, IsOk()); |
[email protected] | 3a120a6b | 2013-06-25 01:08:27 | [diff] [blame] | 4806 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4807 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4808 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4809 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 3a120a6b | 2013-06-25 01:08:27 | [diff] [blame] | 4810 | SendRequestAndExpectQuicResponse("hello!"); |
| 4811 | } |
| 4812 | |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4813 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) { |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 4814 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| 4815 | "PROXY myproxy:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4816 | |
| 4817 | // Since we are using a proxy, the QUIC job will not succeed. |
| 4818 | MockWrite http_writes[] = { |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4819 | MockWrite(SYNCHRONOUS, 0, "GET http://mail.example.org/ HTTP/1.1\r\n"), |
| 4820 | MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4821 | MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n")}; |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4822 | |
| 4823 | MockRead http_reads[] = { |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4824 | MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"), |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 4825 | MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4826 | MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)}; |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4827 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 4828 | StaticSocketDataProvider http_data(http_reads, http_writes); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4829 | socket_factory_.AddSocketDataProvider(&http_data); |
| 4830 | |
| 4831 | // In order for a new QUIC session to be established via alternate-protocol |
| 4832 | // without racing an HTTP connection, we need the host resolution to happen |
| 4833 | // synchronously. |
| 4834 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4835 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4836 | ""); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4837 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4838 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 4839 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 4840 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 4841 | CompletionOnceCallback(), &request, |
| 4842 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 4843 | EXPECT_THAT(rv, IsOk()); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4844 | |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4845 | request_.url = GURL("http://mail.example.org/"); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4846 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4847 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 0fc924b | 2014-03-31 04:34:15 | [diff] [blame] | 4848 | SendRequestAndExpectHttpResponse("hello world"); |
| 4849 | } |
| 4850 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4851 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) { |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 4852 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4853 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 4854 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 4855 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 4856 | mock_quic_data.AddWrite( |
| 4857 | SYNCHRONOUS, |
| 4858 | ConstructClientRequestHeadersPacket( |
| 4859 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 4860 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 4861 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 4862 | 1, GetNthClientInitiatedStreamId(0), false, |
| 4863 | false, GetResponseHeaders("200 OK"))); |
| 4864 | mock_quic_data.AddRead( |
| 4865 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 4866 | false, true, 0, "hello!")); |
| 4867 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 4868 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 4869 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4870 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 4871 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 4872 | // the alternate-protocol job will "win". |
| 4873 | AddHangingNonAlternateProtocolSocketData(); |
| 4874 | |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4875 | // In order for a new QUIC session to be established via alternate-protocol |
| 4876 | // without racing an HTTP connection, we need the host resolution to happen |
| 4877 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 4878 | // connection to the the server, in this test we require confirmation |
| 4879 | // before encrypting so the HTTP job will still start. |
| 4880 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4881 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 4882 | ""); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 4883 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4884 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 4885 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 4886 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 4887 | CompletionOnceCallback(), &request, |
| 4888 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 4889 | EXPECT_THAT(rv, IsOk()); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4890 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 4891 | CreateSession(); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4892 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4893 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4894 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4895 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4896 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 4897 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4898 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4899 | |
| 4900 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 4901 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 4902 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 4903 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 4904 | CheckWasQuicResponse(&trans); |
| 4905 | CheckResponseData(&trans, "hello!"); |
[email protected] | 11c0587 | 2013-08-20 02:04:12 | [diff] [blame] | 4906 | } |
| 4907 | |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4908 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithTooEarlyResponse) { |
| 4909 | MockQuicData mock_quic_data; |
| 4910 | quic::QuicStreamOffset client_header_stream_offset = 0; |
| 4911 | quic::QuicStreamOffset server_header_stream_offset = 0; |
| 4912 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 4913 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
| 4914 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 4915 | ConstructClientRequestHeadersPacket( |
| 4916 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 4917 | GetRequestHeaders("GET", "https", "/"), |
| 4918 | &client_header_stream_offset)); |
| 4919 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 4920 | 1, GetNthClientInitiatedStreamId(0), false, |
| 4921 | false, GetResponseHeaders("425 TOO_EARLY"), |
| 4922 | &server_header_stream_offset)); |
| 4923 | mock_quic_data.AddWrite( |
| 4924 | SYNCHRONOUS, |
| 4925 | ConstructClientAckAndRstPacket(2, GetNthClientInitiatedStreamId(0), |
| 4926 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
| 4927 | |
| 4928 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| 4929 | |
| 4930 | spdy::SpdySettingsIR settings_frame; |
| 4931 | settings_frame.AddSetting(spdy::SETTINGS_MAX_HEADER_LIST_SIZE, |
| 4932 | quic::kDefaultMaxUncompressedHeaderSize); |
| 4933 | spdy::SpdySerializedFrame spdy_frame( |
| 4934 | client_maker_.spdy_request_framer()->SerializeFrame(settings_frame)); |
| 4935 | mock_quic_data.AddWrite( |
| 4936 | SYNCHRONOUS, |
| 4937 | client_maker_.MakeDataPacket( |
| 4938 | 3, 3, false, false, client_header_stream_offset, |
| 4939 | quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()))); |
| 4940 | client_header_stream_offset += spdy_frame.size(); |
| 4941 | |
| 4942 | mock_quic_data.AddWrite( |
| 4943 | SYNCHRONOUS, |
| 4944 | ConstructClientRequestHeadersPacket( |
| 4945 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 4946 | GetRequestHeaders("GET", "https", "/"), |
| 4947 | GetNthClientInitiatedStreamId(0), &client_header_stream_offset)); |
| 4948 | mock_quic_data.AddRead( |
| 4949 | ASYNC, ConstructServerResponseHeadersPacket( |
| 4950 | 2, GetNthClientInitiatedStreamId(1), false, false, |
| 4951 | GetResponseHeaders("200 OK"), &server_header_stream_offset)); |
| 4952 | mock_quic_data.AddRead( |
| 4953 | ASYNC, ConstructServerDataPacket(3, GetNthClientInitiatedStreamId(1), |
| 4954 | false, true, 0, "hello!")); |
| 4955 | mock_quic_data.AddWrite( |
| 4956 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(5, 3, 1, 1)); |
| 4957 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 4958 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 4959 | |
| 4960 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 4961 | |
| 4962 | // In order for a new QUIC session to be established via alternate-protocol |
| 4963 | // without racing an HTTP connection, we need the host resolution to happen |
| 4964 | // synchronously. |
| 4965 | host_resolver_.set_synchronous_mode(true); |
| 4966 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 4967 | ""); |
| 4968 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 4969 | AddressList address; |
| 4970 | std::unique_ptr<HostResolver::Request> request; |
| 4971 | host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 4972 | CompletionOnceCallback(), &request, net_log_.bound()); |
| 4973 | |
| 4974 | AddHangingNonAlternateProtocolSocketData(); |
| 4975 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 4976 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 4977 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 4978 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 4979 | session_->quic_stream_factory(), |
| 4980 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 4981 | &clock_)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 4982 | |
| 4983 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 4984 | TestCompletionCallback callback; |
| 4985 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 4986 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 4987 | |
| 4988 | // Confirm the handshake after the 425 Too Early. |
| 4989 | base::RunLoop().RunUntilIdle(); |
| 4990 | |
| 4991 | // The handshake hasn't been confirmed yet, so the retry should not have |
| 4992 | // succeeded. |
| 4993 | EXPECT_FALSE(callback.have_result()); |
| 4994 | |
| 4995 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 4996 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 4997 | |
| 4998 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 4999 | CheckWasQuicResponse(&trans); |
| 5000 | CheckResponseData(&trans, "hello!"); |
| 5001 | } |
| 5002 | |
| 5003 | TEST_P(QuicNetworkTransactionTest, ZeroRTTWithMultipleTooEarlyResponse) { |
| 5004 | MockQuicData mock_quic_data; |
| 5005 | quic::QuicStreamOffset client_header_stream_offset = 0; |
| 5006 | quic::QuicStreamOffset server_header_stream_offset = 0; |
| 5007 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 5008 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
| 5009 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5010 | ConstructClientRequestHeadersPacket( |
| 5011 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 5012 | GetRequestHeaders("GET", "https", "/"), |
| 5013 | &client_header_stream_offset)); |
| 5014 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5015 | 1, GetNthClientInitiatedStreamId(0), false, |
| 5016 | false, GetResponseHeaders("425 TOO_EARLY"), |
| 5017 | &server_header_stream_offset)); |
| 5018 | mock_quic_data.AddWrite( |
| 5019 | SYNCHRONOUS, |
| 5020 | ConstructClientAckAndRstPacket(2, GetNthClientInitiatedStreamId(0), |
| 5021 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
| 5022 | |
| 5023 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE); |
| 5024 | |
| 5025 | spdy::SpdySettingsIR settings_frame; |
| 5026 | settings_frame.AddSetting(spdy::SETTINGS_MAX_HEADER_LIST_SIZE, |
| 5027 | quic::kDefaultMaxUncompressedHeaderSize); |
| 5028 | spdy::SpdySerializedFrame spdy_frame( |
| 5029 | client_maker_.spdy_request_framer()->SerializeFrame(settings_frame)); |
| 5030 | mock_quic_data.AddWrite( |
| 5031 | SYNCHRONOUS, |
| 5032 | client_maker_.MakeDataPacket( |
| 5033 | 3, 3, false, false, client_header_stream_offset, |
| 5034 | quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()))); |
| 5035 | client_header_stream_offset += spdy_frame.size(); |
| 5036 | |
| 5037 | mock_quic_data.AddWrite( |
| 5038 | SYNCHRONOUS, |
| 5039 | ConstructClientRequestHeadersPacket( |
| 5040 | 4, GetNthClientInitiatedStreamId(1), false, true, |
| 5041 | GetRequestHeaders("GET", "https", "/"), |
| 5042 | GetNthClientInitiatedStreamId(0), &client_header_stream_offset)); |
| 5043 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5044 | 2, GetNthClientInitiatedStreamId(1), false, |
| 5045 | false, GetResponseHeaders("425 TOO_EARLY"), |
| 5046 | &server_header_stream_offset)); |
| 5047 | mock_quic_data.AddWrite( |
| 5048 | SYNCHRONOUS, |
| 5049 | ConstructClientAckAndRstPacket(5, GetNthClientInitiatedStreamId(1), |
| 5050 | quic::QUIC_STREAM_CANCELLED, 2, 1, 1)); |
| 5051 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 5052 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 5053 | |
| 5054 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5055 | |
| 5056 | // In order for a new QUIC session to be established via alternate-protocol |
| 5057 | // without racing an HTTP connection, we need the host resolution to happen |
| 5058 | // synchronously. |
| 5059 | host_resolver_.set_synchronous_mode(true); |
| 5060 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 5061 | ""); |
| 5062 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 5063 | AddressList address; |
| 5064 | std::unique_ptr<HostResolver::Request> request; |
| 5065 | host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 5066 | CompletionOnceCallback(), &request, net_log_.bound()); |
| 5067 | |
| 5068 | AddHangingNonAlternateProtocolSocketData(); |
| 5069 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5070 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 5071 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 5072 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 5073 | session_->quic_stream_factory(), |
| 5074 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 5075 | &clock_)); |
Steven Valdez | 58097ec3 | 2018-07-16 18:29:04 | [diff] [blame] | 5076 | |
| 5077 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5078 | TestCompletionCallback callback; |
| 5079 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5080 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5081 | |
| 5082 | // Confirm the handshake after the 425 Too Early. |
| 5083 | base::RunLoop().RunUntilIdle(); |
| 5084 | |
| 5085 | // The handshake hasn't been confirmed yet, so the retry should not have |
| 5086 | // succeeded. |
| 5087 | EXPECT_FALSE(callback.have_result()); |
| 5088 | |
| 5089 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 5090 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
| 5091 | |
| 5092 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 5093 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
| 5094 | ASSERT_TRUE(response != nullptr); |
| 5095 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 5096 | EXPECT_EQ("HTTP/1.1 425 TOO_EARLY", response->headers->GetStatusLine()); |
| 5097 | EXPECT_TRUE(response->was_fetched_via_spdy); |
| 5098 | EXPECT_TRUE(response->was_alpn_negotiated); |
| 5099 | EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_), |
| 5100 | response->connection_info); |
| 5101 | } |
| 5102 | |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5103 | TEST_P(QuicNetworkTransactionTest, |
| 5104 | LogGranularQuicErrorCodeOnQuicProtocolErrorLocal) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 5105 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5106 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5107 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 5108 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5109 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 5110 | mock_quic_data.AddWrite( |
| 5111 | SYNCHRONOUS, |
| 5112 | ConstructClientRequestHeadersPacket( |
| 5113 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5114 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5115 | // Read a close connection packet with |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5116 | // quic::QuicErrorCode: quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED from the peer. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5117 | mock_quic_data.AddRead(ASYNC, ConstructServerConnectionClosePacket(1)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5118 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5119 | |
| 5120 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5121 | // the alternate-protocol job will "win". |
| 5122 | AddHangingNonAlternateProtocolSocketData(); |
| 5123 | |
| 5124 | // In order for a new QUIC session to be established via alternate-protocol |
| 5125 | // without racing an HTTP connection, we need the host resolution to happen |
| 5126 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 5127 | // connection to the the server, in this test we require confirmation |
| 5128 | // before encrypting so the HTTP job will still start. |
| 5129 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 5130 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5131 | ""); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 5132 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5133 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 5134 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 5135 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 5136 | CompletionOnceCallback(), &request, |
| 5137 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5138 | EXPECT_THAT(rv, IsOk()); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5139 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5140 | CreateSession(); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5141 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5142 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5143 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5144 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5145 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5146 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5147 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5148 | |
| 5149 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5150 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5151 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5152 | |
| 5153 | NetErrorDetails details; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5154 | EXPECT_EQ(quic::QUIC_NO_ERROR, details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5155 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5156 | trans.PopulateNetErrorDetails(&details); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5157 | // Verify the error code logged is what sent by the peer. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5158 | EXPECT_EQ(quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, |
| 5159 | details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5160 | } |
| 5161 | |
| 5162 | TEST_P(QuicNetworkTransactionTest, |
| 5163 | LogGranularQuicErrorCodeOnQuicProtocolErrorRemote) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 5164 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5165 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5166 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 5167 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5168 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 5169 | mock_quic_data.AddWrite( |
| 5170 | SYNCHRONOUS, |
| 5171 | ConstructClientRequestHeadersPacket( |
| 5172 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5173 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
zhongyi | f28b4a3 | 2016-04-25 21:35:21 | [diff] [blame] | 5174 | // Peer sending data from an non-existing stream causes this end to raise |
| 5175 | // error and close connection. |
| 5176 | mock_quic_data.AddRead( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5177 | ASYNC, |
| 5178 | ConstructServerRstPacket(1, false, 99, quic::QUIC_STREAM_LAST_ERROR)); |
zhongyi | f28b4a3 | 2016-04-25 21:35:21 | [diff] [blame] | 5179 | std::string quic_error_details = "Data for nonexistent stream"; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5180 | mock_quic_data.AddWrite( |
| 5181 | SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket( |
| 5182 | 3, quic::QuicTime::Delta::Zero(), 1, 1, 1, |
| 5183 | quic::QUIC_INVALID_STREAM_ID, quic_error_details)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5184 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5185 | |
| 5186 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5187 | // the alternate-protocol job will "win". |
| 5188 | AddHangingNonAlternateProtocolSocketData(); |
| 5189 | |
| 5190 | // In order for a new QUIC session to be established via alternate-protocol |
| 5191 | // without racing an HTTP connection, we need the host resolution to happen |
| 5192 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 5193 | // connection to the the server, in this test we require confirmation |
| 5194 | // before encrypting so the HTTP job will still start. |
| 5195 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 5196 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5197 | ""); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 5198 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5199 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 5200 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 5201 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 5202 | CompletionOnceCallback(), &request, |
| 5203 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5204 | EXPECT_THAT(rv, IsOk()); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5205 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5206 | CreateSession(); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5207 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5208 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5209 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5210 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5211 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5212 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5213 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5214 | |
| 5215 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5216 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5217 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5218 | NetErrorDetails details; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5219 | EXPECT_EQ(quic::QUIC_NO_ERROR, details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5220 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5221 | trans.PopulateNetErrorDetails(&details); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5222 | EXPECT_EQ(quic::QUIC_INVALID_STREAM_ID, details.quic_connection_error); |
zhongyi | ca364fbb | 2015-12-12 03:39:12 | [diff] [blame] | 5223 | } |
| 5224 | |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5225 | TEST_P(QuicNetworkTransactionTest, RstSteamErrorHandling) { |
| 5226 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5227 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 5228 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5229 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 5230 | mock_quic_data.AddWrite( |
| 5231 | SYNCHRONOUS, |
| 5232 | ConstructClientRequestHeadersPacket( |
| 5233 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5234 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5235 | // Read the response headers, then a RST_STREAM frame. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5236 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5237 | 1, GetNthClientInitiatedStreamId(0), false, |
| 5238 | false, GetResponseHeaders("200 OK"))); |
| 5239 | mock_quic_data.AddRead(ASYNC, ConstructServerRstPacket( |
| 5240 | 2, false, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5241 | quic::QUIC_STREAM_CANCELLED)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5242 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5243 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
| 5244 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5245 | |
| 5246 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5247 | // the alternate-protocol job will "win". |
| 5248 | AddHangingNonAlternateProtocolSocketData(); |
| 5249 | |
| 5250 | // In order for a new QUIC session to be established via alternate-protocol |
| 5251 | // without racing an HTTP connection, we need the host resolution to happen |
| 5252 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 5253 | // connection to the the server, in this test we require confirmation |
| 5254 | // before encrypting so the HTTP job will still start. |
| 5255 | host_resolver_.set_synchronous_mode(true); |
| 5256 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 5257 | ""); |
| 5258 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 5259 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 5260 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 5261 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 5262 | CompletionOnceCallback(), &request, |
| 5263 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5264 | EXPECT_THAT(rv, IsOk()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5265 | |
| 5266 | CreateSession(); |
| 5267 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5268 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5269 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5270 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5271 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5272 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5273 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5274 | |
| 5275 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5276 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5277 | // Read the headers. |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5278 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5279 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5280 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5281 | ASSERT_TRUE(response != nullptr); |
| 5282 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 5283 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 5284 | EXPECT_TRUE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 5285 | EXPECT_TRUE(response->was_alpn_negotiated); |
bnc | 90be5dd78 | 2016-11-09 16:28:44 | [diff] [blame] | 5286 | EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_), |
| 5287 | response->connection_info); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5288 | |
| 5289 | std::string response_data; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5290 | ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, ReadTransaction(&trans, &response_data)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5291 | } |
| 5292 | |
| 5293 | TEST_P(QuicNetworkTransactionTest, RstSteamBeforeHeaders) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 5294 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5295 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5296 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 5297 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5298 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 5299 | mock_quic_data.AddWrite( |
| 5300 | SYNCHRONOUS, |
| 5301 | ConstructClientRequestHeadersPacket( |
| 5302 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5303 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 5304 | mock_quic_data.AddRead(ASYNC, ConstructServerRstPacket( |
| 5305 | 1, false, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5306 | quic::QUIC_STREAM_CANCELLED)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5307 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
| 5308 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5309 | |
| 5310 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5311 | // the alternate-protocol job will "win". |
| 5312 | AddHangingNonAlternateProtocolSocketData(); |
| 5313 | |
| 5314 | // In order for a new QUIC session to be established via alternate-protocol |
| 5315 | // without racing an HTTP connection, we need the host resolution to happen |
| 5316 | // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
| 5317 | // connection to the the server, in this test we require confirmation |
| 5318 | // before encrypting so the HTTP job will still start. |
| 5319 | host_resolver_.set_synchronous_mode(true); |
| 5320 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
| 5321 | ""); |
| 5322 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
| 5323 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 5324 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 5325 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 5326 | CompletionOnceCallback(), &request, |
| 5327 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5328 | EXPECT_THAT(rv, IsOk()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5329 | |
| 5330 | CreateSession(); |
| 5331 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5332 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5333 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5334 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5335 | TestCompletionCallback callback; |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5336 | rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5337 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5338 | |
| 5339 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5340 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5341 | // Read the headers. |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5342 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
rch | cd5f1c6 | 2016-06-23 02:43:48 | [diff] [blame] | 5343 | } |
| 5344 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 5345 | TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) { |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5346 | // Alternate-protocol job |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5347 | std::unique_ptr<quic::QuicEncryptedPacket> close( |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 5348 | ConstructServerConnectionClosePacket(1)); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5349 | MockRead quic_reads[] = { |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 5350 | MockRead(ASYNC, close->data(), close->length()), |
| 5351 | MockRead(ASYNC, ERR_IO_PENDING), // No more data to read |
| 5352 | MockRead(ASYNC, OK), // EOF |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5353 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5354 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5355 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5356 | |
| 5357 | // Main job which will succeed even though the alternate job fails. |
| 5358 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5359 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5360 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5361 | MockRead(ASYNC, OK)}; |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5362 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5363 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5364 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5365 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5366 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5367 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5368 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 5369 | SendRequestAndExpectHttpResponse("hello from http"); |
| 5370 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | 3316d42 | 2013-05-03 21:45:30 | [diff] [blame] | 5371 | } |
| 5372 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 5373 | TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) { |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5374 | // Alternate-protocol job |
| 5375 | MockRead quic_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5376 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5377 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5378 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5379 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5380 | |
| 5381 | // Main job which will succeed even though the alternate job fails. |
| 5382 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5383 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5384 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5385 | MockRead(ASYNC, OK)}; |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5386 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5387 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5388 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5389 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5390 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5391 | CreateSession(); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5392 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5393 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
[email protected] | aa9b14d | 2013-05-10 23:45:19 | [diff] [blame] | 5394 | SendRequestAndExpectHttpResponse("hello from http"); |
| 5395 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | d03a66d | 2013-05-06 12:55:59 | [diff] [blame] | 5396 | } |
| 5397 | |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5398 | TEST_P(QuicNetworkTransactionTest, NoBrokenAlternateProtocolIfTcpFails) { |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 5399 | // Alternate-protocol job will fail when the session attempts to read. |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5400 | MockRead quic_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5401 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5402 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5403 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5404 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5405 | |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 5406 | // Main job will also fail. |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5407 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5408 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5409 | }; |
| 5410 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5411 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5412 | http_data.set_connect_data(MockConnect(ASYNC, ERR_SOCKET_NOT_CONNECTED)); |
| 5413 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5414 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5415 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5416 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5417 | CreateSession(); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5418 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5419 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5420 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5421 | TestCompletionCallback callback; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5422 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5423 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5424 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_SOCKET_NOT_CONNECTED)); |
[email protected] | 00c159f | 2014-05-21 22:38:16 | [diff] [blame] | 5425 | ExpectQuicAlternateProtocolMapping(); |
| 5426 | } |
| 5427 | |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5428 | TEST_P(QuicNetworkTransactionTest, DelayTCPOnStartWithQuicSupportOnSameIP) { |
| 5429 | // Tests that TCP job is delayed and QUIC job does not require confirmation |
| 5430 | // if QUIC was recently supported on the same IP on start. |
| 5431 | |
| 5432 | // Set QUIC support on the last IP address, which is same with the local IP |
| 5433 | // address. Require confirmation mode will be turned off immediately when |
| 5434 | // local IP address is sorted out after we configure the UDP socket. |
| 5435 | http_server_properties_.SetSupportsQuic(true, IPAddress(192, 0, 2, 33)); |
| 5436 | |
| 5437 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5438 | quic::QuicStreamOffset header_stream_offset = 0; |
| 5439 | client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL); |
| 5440 | client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5441 | mock_quic_data.AddWrite( |
| 5442 | SYNCHRONOUS, |
| 5443 | ConstructClientRequestHeadersPacket( |
| 5444 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 5445 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 5446 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5447 | 1, GetNthClientInitiatedStreamId(0), false, |
| 5448 | false, GetResponseHeaders("200 OK"))); |
| 5449 | mock_quic_data.AddRead( |
| 5450 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 5451 | false, true, 0, "hello!")); |
| 5452 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 2, 1, 1)); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5453 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 5454 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 5455 | |
| 5456 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5457 | // No HTTP data is mocked as TCP job never starts in this case. |
| 5458 | |
| 5459 | CreateSession(); |
| 5460 | // QuicStreamFactory by default requires confirmation on construction. |
| 5461 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 5462 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5463 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5464 | |
| 5465 | // Stall host resolution so that QUIC job will not succeed synchronously. |
| 5466 | // Socket will not be configured immediately and QUIC support is not sorted |
| 5467 | // out, TCP job will still be delayed as server properties indicates QUIC |
| 5468 | // support on last IP address. |
| 5469 | host_resolver_.set_synchronous_mode(false); |
| 5470 | |
| 5471 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5472 | TestCompletionCallback callback; |
| 5473 | EXPECT_THAT(trans.Start(&request_, callback.callback(), net_log_.bound()), |
| 5474 | IsError(ERR_IO_PENDING)); |
| 5475 | // Complete host resolution in next message loop so that QUIC job could |
| 5476 | // proceed. |
| 5477 | base::RunLoop().RunUntilIdle(); |
| 5478 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 5479 | |
| 5480 | CheckWasQuicResponse(&trans); |
| 5481 | CheckResponseData(&trans, "hello!"); |
| 5482 | } |
| 5483 | |
| 5484 | TEST_P(QuicNetworkTransactionTest, |
| 5485 | DelayTCPOnStartWithQuicSupportOnDifferentIP) { |
| 5486 | // Tests that TCP job is delayed and QUIC job requires confirmation if QUIC |
| 5487 | // was recently supported on a different IP address on start. |
| 5488 | |
| 5489 | // Set QUIC support on the last IP address, which is different with the local |
| 5490 | // IP address. Require confirmation mode will remain when local IP address is |
| 5491 | // sorted out after we configure the UDP socket. |
| 5492 | http_server_properties_.SetSupportsQuic(true, IPAddress(1, 2, 3, 4)); |
| 5493 | |
| 5494 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5495 | quic::QuicStreamOffset header_stream_offset = 0; |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5496 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5497 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 5498 | mock_quic_data.AddWrite( |
| 5499 | SYNCHRONOUS, |
| 5500 | ConstructClientRequestHeadersPacket( |
| 5501 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5502 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 5503 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5504 | 1, GetNthClientInitiatedStreamId(0), false, |
| 5505 | false, GetResponseHeaders("200 OK"))); |
| 5506 | mock_quic_data.AddRead( |
| 5507 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 5508 | false, true, 0, "hello!")); |
| 5509 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5510 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 5511 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5512 | // No HTTP data is mocked as TCP job will be delayed and never starts. |
| 5513 | |
| 5514 | CreateSession(); |
| 5515 | session_->quic_stream_factory()->set_require_confirmation(true); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5516 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5517 | |
| 5518 | // Stall host resolution so that QUIC job could not proceed and unblocks TCP. |
| 5519 | // Socket will not be configured immediately and QUIC support is not sorted |
| 5520 | // out, TCP job will still be delayed as server properties indicates QUIC |
| 5521 | // support on last IP address. |
| 5522 | host_resolver_.set_synchronous_mode(false); |
| 5523 | |
| 5524 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5525 | TestCompletionCallback callback; |
| 5526 | EXPECT_THAT(trans.Start(&request_, callback.callback(), net_log_.bound()), |
| 5527 | IsError(ERR_IO_PENDING)); |
| 5528 | |
| 5529 | // Complete host resolution in next message loop so that QUIC job could |
| 5530 | // proceed. |
| 5531 | base::RunLoop().RunUntilIdle(); |
| 5532 | // Explicitly confirm the handshake so that QUIC job could succeed. |
| 5533 | crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5534 | quic::QuicSession::HANDSHAKE_CONFIRMED); |
Zhongyi Shi | a0cef108 | 2017-08-25 01:49:50 | [diff] [blame] | 5535 | EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| 5536 | |
| 5537 | CheckWasQuicResponse(&trans); |
| 5538 | CheckResponseData(&trans, "hello!"); |
| 5539 | } |
| 5540 | |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5541 | TEST_P(QuicNetworkTransactionTest, NetErrorDetailsSetBeforeHandshake) { |
| 5542 | // Test that NetErrorDetails is correctly populated, even if the |
| 5543 | // handshake has not yet been confirmed and no stream has been created. |
| 5544 | |
| 5545 | // QUIC job will pause. When resumed, it will fail. |
| 5546 | MockQuicData mock_quic_data; |
| 5547 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 5548 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED); |
| 5549 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5550 | |
| 5551 | // Main job will also fail. |
| 5552 | MockRead http_reads[] = { |
| 5553 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
| 5554 | }; |
| 5555 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5556 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5557 | http_data.set_connect_data(MockConnect(ASYNC, ERR_SOCKET_NOT_CONNECTED)); |
| 5558 | socket_factory_.AddSocketDataProvider(&http_data); |
| 5559 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 5560 | |
| 5561 | AddHangingNonAlternateProtocolSocketData(); |
| 5562 | CreateSession(); |
| 5563 | // Require handshake confirmation to ensure that no QUIC streams are |
| 5564 | // created, and to ensure that the TCP job does not wait for the QUIC |
| 5565 | // job to fail before it starts. |
| 5566 | session_->quic_stream_factory()->set_require_confirmation(true); |
| 5567 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5568 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5569 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5570 | TestCompletionCallback callback; |
| 5571 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5572 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5573 | // Allow the TCP job to fail. |
| 5574 | base::RunLoop().RunUntilIdle(); |
| 5575 | // Now let the QUIC job fail. |
| 5576 | mock_quic_data.Resume(); |
| 5577 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 5578 | ExpectQuicAlternateProtocolMapping(); |
| 5579 | NetErrorDetails details; |
| 5580 | trans.PopulateNetErrorDetails(&details); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5581 | EXPECT_EQ(quic::QUIC_PACKET_READ_ERROR, details.quic_connection_error); |
Ryan Hamilton | 75f19726 | 2017-08-17 14:00:07 | [diff] [blame] | 5582 | } |
| 5583 | |
[email protected] | 1e96003 | 2013-12-20 19:00:20 | [diff] [blame] | 5584 | TEST_P(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) { |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5585 | // Alternate-protocol job |
| 5586 | MockRead quic_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5587 | MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED), |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5588 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5589 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5590 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5591 | |
[email protected] | c92c1b5 | 2014-05-31 04:16:06 | [diff] [blame] | 5592 | // Second Alternate-protocol job which will race with the TCP job. |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5593 | StaticSocketDataProvider quic_data2(quic_reads, base::span<MockWrite>()); |
[email protected] | c92c1b5 | 2014-05-31 04:16:06 | [diff] [blame] | 5594 | socket_factory_.AddSocketDataProvider(&quic_data2); |
| 5595 | |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5596 | // Final job that will proceed when the QUIC job fails. |
| 5597 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5598 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5599 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5600 | MockRead(ASYNC, OK)}; |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5601 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5602 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5603 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5604 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5605 | |
rtenneti | afccbc06 | 2016-05-16 18:21:14 | [diff] [blame] | 5606 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5607 | CreateSession(); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5608 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5609 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5610 | |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5611 | SendRequestAndExpectHttpResponse("hello from http"); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5612 | |
| 5613 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | 4d283b3 | 2013-10-17 12:57:27 | [diff] [blame] | 5614 | |
rch | 37de576c | 2015-05-17 20:28:17 | [diff] [blame] | 5615 | EXPECT_TRUE(quic_data.AllReadDataConsumed()); |
| 5616 | EXPECT_TRUE(quic_data.AllWriteDataConsumed()); |
[email protected] | 77c6c16 | 2013-08-17 02:57:45 | [diff] [blame] | 5617 | } |
| 5618 | |
[email protected] | 93b3177 | 2014-06-19 08:03:35 | [diff] [blame] | 5619 | TEST_P(QuicNetworkTransactionTest, DISABLED_HangingZeroRttFallback) { |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5620 | // Alternate-protocol job |
| 5621 | MockRead quic_reads[] = { |
mmenke | e2401192 | 2015-12-17 22:12:59 | [diff] [blame] | 5622 | MockRead(SYNCHRONOUS, ERR_IO_PENDING), |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5623 | }; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5624 | StaticSocketDataProvider quic_data(quic_reads, base::span<MockWrite>()); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5625 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5626 | |
| 5627 | // Main job that will proceed when the QUIC job fails. |
| 5628 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5629 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5630 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5631 | MockRead(ASYNC, OK)}; |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5632 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5633 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5634 | socket_factory_.AddSocketDataProvider(&http_data); |
| 5635 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5636 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5637 | CreateSession(); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5638 | |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5639 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 6576844 | 2014-06-06 23:37:03 | [diff] [blame] | 5640 | |
| 5641 | SendRequestAndExpectHttpResponse("hello from http"); |
| 5642 | } |
| 5643 | |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 5644 | TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolOnConnectFailure) { |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5645 | // Alternate-protocol job will fail before creating a QUIC session. |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5646 | StaticSocketDataProvider quic_data; |
tbansal | 6b52748 | 2017-01-27 19:10:49 | [diff] [blame] | 5647 | quic_data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5648 | socket_factory_.AddSocketDataProvider(&quic_data); |
| 5649 | |
| 5650 | // Main job which will succeed even though the alternate job fails. |
| 5651 | MockRead http_reads[] = { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 5652 | MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"), |
| 5653 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5654 | MockRead(ASYNC, OK)}; |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5655 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5656 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5657 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5658 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5659 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5660 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5661 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5662 | SendRequestAndExpectHttpResponse("hello from http"); |
[email protected] | eb71ab6 | 2014-05-23 07:57:53 | [diff] [blame] | 5663 | |
| 5664 | ExpectBrokenAlternateProtocolMapping(); |
[email protected] | 4d590c9c | 2014-05-02 05:14:33 | [diff] [blame] | 5665 | } |
| 5666 | |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5667 | TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) { |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5668 | MockQuicData mock_quic_data; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5669 | mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerConnectionClosePacket(1)); |
| 5670 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5671 | ConstructClientRequestHeadersPacket( |
| 5672 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 5673 | GetRequestHeaders("GET", "https", "/"))); |
| 5674 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 1, 1, 1)); |
rch | a5399e0 | 2015-04-21 19:32:04 | [diff] [blame] | 5675 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5676 | |
| 5677 | // When the QUIC connection fails, we will try the request again over HTTP. |
| 5678 | MockRead http_reads[] = { |
bnc | 1c196c6e | 2016-05-28 13:51:48 | [diff] [blame] | 5679 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5680 | MockRead("hello world"), |
| 5681 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5682 | MockRead(ASYNC, OK)}; |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5683 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5684 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5685 | socket_factory_.AddSocketDataProvider(&http_data); |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5686 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5687 | |
| 5688 | // In order for a new QUIC session to be established via alternate-protocol |
| 5689 | // without racing an HTTP connection, we need the host resolution to happen |
| 5690 | // synchronously. |
| 5691 | host_resolver_.set_synchronous_mode(true); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 5692 | host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
rch | f114d98 | 2015-10-21 01:34:56 | [diff] [blame] | 5693 | ""); |
rch | 9ae5b3b | 2016-02-11 00:36:29 | [diff] [blame] | 5694 | HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443)); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5695 | AddressList address; |
maksim.sisov | 31452af | 2016-07-27 06:38:10 | [diff] [blame] | 5696 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 5697 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 5698 | CompletionOnceCallback(), &request, |
| 5699 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5700 | EXPECT_THAT(rv, IsOk()); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5701 | |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5702 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5703 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
[email protected] | 4fee967 | 2014-01-08 14:47:15 | [diff] [blame] | 5704 | SendRequestAndExpectHttpResponse("hello world"); |
| 5705 | } |
| 5706 | |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5707 | // For an alternative proxy that supports QUIC, test that the request is |
| 5708 | // successfully fetched by the main job when the alternate proxy job encounters |
| 5709 | // an error. |
| 5710 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxySocketNotConnected) { |
| 5711 | TestAlternativeProxy(ERR_SOCKET_NOT_CONNECTED); |
| 5712 | } |
| 5713 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyConnectionFailed) { |
| 5714 | TestAlternativeProxy(ERR_CONNECTION_FAILED); |
| 5715 | } |
| 5716 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyConnectionTimedOut) { |
| 5717 | TestAlternativeProxy(ERR_CONNECTION_TIMED_OUT); |
| 5718 | } |
| 5719 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyConnectionRefused) { |
| 5720 | TestAlternativeProxy(ERR_CONNECTION_REFUSED); |
| 5721 | } |
| 5722 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyQuicHandshakeFailed) { |
| 5723 | TestAlternativeProxy(ERR_QUIC_HANDSHAKE_FAILED); |
| 5724 | } |
| 5725 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyQuicProtocolError) { |
| 5726 | TestAlternativeProxy(ERR_QUIC_PROTOCOL_ERROR); |
| 5727 | } |
| 5728 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyIOPending) { |
| 5729 | TestAlternativeProxy(ERR_IO_PENDING); |
| 5730 | } |
| 5731 | TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyAddressUnreachable) { |
| 5732 | TestAlternativeProxy(ERR_ADDRESS_UNREACHABLE); |
| 5733 | } |
| 5734 | |
| 5735 | TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnectProxy) { |
| 5736 | MockQuicData mock_quic_data; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5737 | mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerConnectionClosePacket(1)); |
| 5738 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 5739 | ConstructClientRequestHeadersPacket( |
| 5740 | 1, GetNthClientInitiatedStreamId(0), true, true, |
| 5741 | GetRequestHeaders("GET", "https", "/"))); |
| 5742 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(2, 1, 1, 1)); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5743 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5744 | |
| 5745 | // When the QUIC connection fails, we will try the request again over HTTP. |
| 5746 | MockRead http_reads[] = { |
| 5747 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 5748 | MockRead("hello world"), |
| 5749 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 5750 | MockRead(ASYNC, OK)}; |
| 5751 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5752 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5753 | socket_factory_.AddSocketDataProvider(&http_data); |
| 5754 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 5755 | |
| 5756 | TestProxyDelegate test_proxy_delegate; |
| 5757 | const HostPortPair host_port_pair("myproxy.org", 443); |
| 5758 | test_proxy_delegate.set_alternative_proxy_server( |
| 5759 | ProxyServer::FromPacString("QUIC myproxy.org:443")); |
| 5760 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 5761 | |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 5762 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
| 5763 | "HTTPS myproxy.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 5764 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5765 | request_.url = GURL("http://mail.example.org/"); |
| 5766 | |
| 5767 | // In order for a new QUIC session to be established via alternate-protocol |
| 5768 | // without racing an HTTP connection, we need the host resolution to happen |
| 5769 | // synchronously. |
| 5770 | host_resolver_.set_synchronous_mode(true); |
| 5771 | host_resolver_.rules()->AddIPLiteralRule("myproxy.org", "192.168.0.1", ""); |
| 5772 | HostResolver::RequestInfo info(HostPortPair("myproxy.org", 443)); |
| 5773 | AddressList address; |
| 5774 | std::unique_ptr<HostResolver::Request> request; |
Bence Béky | d8a21fc3 | 2018-06-27 18:29:58 | [diff] [blame] | 5775 | int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, |
| 5776 | CompletionOnceCallback(), &request, |
| 5777 | net_log_.bound()); |
Bence Béky | 844d7b1 | 2018-06-04 17:30:41 | [diff] [blame] | 5778 | EXPECT_THAT(rv, IsOk()); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5779 | |
| 5780 | CreateSession(); |
| 5781 | SendRequestAndExpectHttpResponseFromProxy("hello world", true, 443); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 5782 | EXPECT_THAT(session_->proxy_resolution_service()->proxy_retry_info(), |
Reilly Grant | 89a7e51 | 2018-01-20 01:57:16 | [diff] [blame] | 5783 | ElementsAre(Key("quic://myproxy.org:443"))); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5784 | } |
| 5785 | |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5786 | TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 5787 | client_maker_.set_hostname("www.example.org"); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 5788 | EXPECT_FALSE( |
| 5789 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5790 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5791 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 5792 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5793 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 5794 | mock_quic_data.AddWrite( |
| 5795 | SYNCHRONOUS, |
| 5796 | ConstructClientRequestHeadersPacket( |
| 5797 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5798 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 5799 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5800 | 1, GetNthClientInitiatedStreamId(0), false, |
| 5801 | false, GetResponseHeaders("200 OK"))); |
| 5802 | mock_quic_data.AddRead( |
| 5803 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 5804 | false, true, 0, "hello!")); |
| 5805 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
rch | b27683c | 2015-07-29 23:53:50 | [diff] [blame] | 5806 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5807 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 5808 | |
bnc | b07c0553 | 2015-05-14 19:07:20 | [diff] [blame] | 5809 | request_.url = GURL("https://www.example.org:443"); |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5810 | AddHangingNonAlternateProtocolSocketData(); |
rch | 3f4b845 | 2016-02-23 16:59:32 | [diff] [blame] | 5811 | CreateSession(); |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 5812 | AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5813 | SendRequestAndExpectQuicResponse("hello!"); |
tbansal | 0f56a39a | 2016-04-07 22:03:38 | [diff] [blame] | 5814 | EXPECT_TRUE( |
| 5815 | test_socket_performance_watcher_factory_.rtt_notification_received()); |
bnc | 50883590 | 2015-05-12 20:10:29 | [diff] [blame] | 5816 | } |
| 5817 | |
zhongyi | 363c91c | 2017-03-23 23:16:08 | [diff] [blame] | 5818 | // TODO(zhongyi): disabled this broken test as it was not testing the correct |
| 5819 | // code path. Need a fix to re-enable this test, tracking at crbug.com/704596. |
| 5820 | TEST_P(QuicNetworkTransactionTest, |
| 5821 | DISABLED_QuicUploadToAlternativeProxyServer) { |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 5822 | base::HistogramTester histogram_tester; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 5823 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 5824 | "HTTPS mail.example.org:443", TRAFFIC_ANNOTATION_FOR_TESTS); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5825 | |
| 5826 | TestProxyDelegate test_proxy_delegate; |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5827 | |
| 5828 | test_proxy_delegate.set_alternative_proxy_server( |
| 5829 | ProxyServer::FromPacString("QUIC mail.example.org:443")); |
Eric Roman | 3d8546a | 2018-09-10 17:00:52 | [diff] [blame] | 5830 | proxy_resolution_service_->SetProxyDelegate(&test_proxy_delegate); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5831 | |
| 5832 | request_.url = GURL("http://mail.example.org/"); |
| 5833 | |
| 5834 | MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
| 5835 | MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5836 | SequencedSocketData socket_data(reads, writes); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5837 | socket_factory_.AddSocketDataProvider(&socket_data); |
| 5838 | |
| 5839 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5840 | // the alternate-protocol job will "win". |
| 5841 | AddHangingNonAlternateProtocolSocketData(); |
| 5842 | |
| 5843 | CreateSession(); |
| 5844 | request_.method = "POST"; |
| 5845 | ChunkedUploadDataStream upload_data(0); |
| 5846 | upload_data.AppendData("1", 1, true); |
| 5847 | |
| 5848 | request_.upload_data_stream = &upload_data; |
| 5849 | |
| 5850 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 5851 | TestCompletionCallback callback; |
| 5852 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 5853 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5854 | EXPECT_NE(OK, callback.WaitForResult()); |
| 5855 | |
| 5856 | // Verify that the alternative proxy server is not marked as broken. |
| 5857 | EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic()); |
| 5858 | |
| 5859 | // Verify that the proxy server is not marked as broken. |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 5860 | EXPECT_TRUE(session_->proxy_resolution_service()->proxy_retry_info().empty()); |
tbansal | 6490783c | 2016-09-20 17:55:27 | [diff] [blame] | 5861 | |
| 5862 | histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage", |
| 5863 | 1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */, |
| 5864 | 1); |
tbansal | c3308d7 | 2016-08-27 10:25:04 | [diff] [blame] | 5865 | } |
| 5866 | |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5867 | TEST_P(QuicNetworkTransactionTest, QuicUpload) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 5868 | session_params_.origins_to_force_quic_on.insert( |
rtenneti | 8a2f463 | 2016-03-21 20:26:57 | [diff] [blame] | 5869 | HostPortPair::FromString("mail.example.org:443")); |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5870 | |
| 5871 | MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
| 5872 | MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)}; |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 5873 | SequencedSocketData socket_data(reads, writes); |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5874 | socket_factory_.AddSocketDataProvider(&socket_data); |
| 5875 | |
rtenneti | b8e80fb | 2016-05-16 00:12:09 | [diff] [blame] | 5876 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5877 | // the alternate-protocol job will "win". |
| 5878 | AddHangingNonAlternateProtocolSocketData(); |
| 5879 | |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5880 | CreateSession(); |
| 5881 | request_.method = "POST"; |
| 5882 | ChunkedUploadDataStream upload_data(0); |
| 5883 | upload_data.AppendData("1", 1, true); |
| 5884 | |
| 5885 | request_.upload_data_stream = &upload_data; |
| 5886 | |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5887 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5888 | TestCompletionCallback callback; |
bnc | 691fda6 | 2016-08-12 00:43:16 | [diff] [blame] | 5889 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 5890 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
rtenneti | 5697781 | 2016-01-15 19:26:56 | [diff] [blame] | 5891 | EXPECT_NE(OK, callback.WaitForResult()); |
| 5892 | } |
| 5893 | |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5894 | TEST_P(QuicNetworkTransactionTest, QuicUploadWriteError) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 5895 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5896 | ScopedMockNetworkChangeNotifier network_change_notifier; |
| 5897 | MockNetworkChangeNotifier* mock_ncn = |
| 5898 | network_change_notifier.mock_network_change_notifier(); |
| 5899 | mock_ncn->ForceNetworkHandlesSupported(); |
| 5900 | mock_ncn->SetConnectedNetworksList( |
| 5901 | {kDefaultNetworkForTests, kNewNetworkForTests}); |
| 5902 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 5903 | session_params_.origins_to_force_quic_on.insert( |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5904 | HostPortPair::FromString("mail.example.org:443")); |
Zhongyi Shi | c461bdb | 2018-06-26 22:07:31 | [diff] [blame] | 5905 | session_params_.quic_migrate_sessions_on_network_change_v2 = true; |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5906 | |
| 5907 | MockQuicData socket_data; |
| 5908 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5909 | quic::QuicStreamOffset offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5910 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1, &offset)); |
| 5911 | socket_data.AddWrite(SYNCHRONOUS, |
| 5912 | ConstructClientRequestHeadersPacket( |
| 5913 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 5914 | GetRequestHeaders("POST", "https", "/"), &offset)); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5915 | socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
| 5916 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5917 | |
| 5918 | MockQuicData socket_data2; |
| 5919 | socket_data2.AddConnect(SYNCHRONOUS, ERR_ADDRESS_INVALID); |
| 5920 | socket_data2.AddSocketDataToFactory(&socket_factory_); |
| 5921 | |
| 5922 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 5923 | // the alternate-protocol job will "win". |
| 5924 | AddHangingNonAlternateProtocolSocketData(); |
| 5925 | |
| 5926 | CreateSession(); |
| 5927 | request_.method = "POST"; |
| 5928 | ChunkedUploadDataStream upload_data(0); |
| 5929 | |
| 5930 | request_.upload_data_stream = &upload_data; |
| 5931 | |
rdsmith | 1d343be5 | 2016-10-21 20:37:50 | [diff] [blame] | 5932 | std::unique_ptr<HttpNetworkTransaction> trans( |
| 5933 | new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get())); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5934 | TestCompletionCallback callback; |
rdsmith | 1d343be5 | 2016-10-21 20:37:50 | [diff] [blame] | 5935 | int rv = trans->Start(&request_, callback.callback(), net_log_.bound()); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5936 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 5937 | |
| 5938 | base::RunLoop().RunUntilIdle(); |
| 5939 | upload_data.AppendData("1", 1, true); |
| 5940 | base::RunLoop().RunUntilIdle(); |
| 5941 | |
| 5942 | EXPECT_NE(OK, callback.WaitForResult()); |
rdsmith | 1d343be5 | 2016-10-21 20:37:50 | [diff] [blame] | 5943 | trans.reset(); |
rch | e11300ef | 2016-09-02 01:44:28 | [diff] [blame] | 5944 | session_.reset(); |
| 5945 | } |
| 5946 | |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5947 | TEST_P(QuicNetworkTransactionTest, RetryAfterAsyncNoBufferSpace) { |
| 5948 | session_params_.origins_to_force_quic_on.insert( |
| 5949 | HostPortPair::FromString("mail.example.org:443")); |
| 5950 | |
| 5951 | MockQuicData socket_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5952 | quic::QuicStreamOffset offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5953 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1, &offset)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5954 | socket_data.AddWrite(ASYNC, ERR_NO_BUFFER_SPACE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5955 | socket_data.AddWrite(SYNCHRONOUS, |
| 5956 | ConstructClientRequestHeadersPacket( |
| 5957 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5958 | GetRequestHeaders("GET", "https", "/"), &offset)); |
| 5959 | socket_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5960 | 1, GetNthClientInitiatedStreamId(0), false, |
| 5961 | false, GetResponseHeaders("200 OK"))); |
| 5962 | socket_data.AddRead( |
| 5963 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 5964 | false, true, 0, "hello!")); |
| 5965 | socket_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5966 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie | ba55fae | 2018-09-20 03:05:16 | [diff] [blame] | 5967 | socket_data.AddWrite( |
| 5968 | SYNCHRONOUS, client_maker_.MakeAckAndConnectionClosePacket( |
| 5969 | 4, false, quic::QuicTime::Delta::FromMilliseconds(0), 2, |
| 5970 | 1, 1, quic::QUIC_CONNECTION_CANCELLED, "net error")); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5971 | |
| 5972 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 5973 | |
| 5974 | CreateSession(); |
| 5975 | |
| 5976 | SendRequestAndExpectQuicResponse("hello!"); |
| 5977 | session_.reset(); |
| 5978 | } |
| 5979 | |
| 5980 | TEST_P(QuicNetworkTransactionTest, RetryAfterSynchronousNoBufferSpace) { |
| 5981 | session_params_.origins_to_force_quic_on.insert( |
| 5982 | HostPortPair::FromString("mail.example.org:443")); |
| 5983 | |
| 5984 | MockQuicData socket_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 5985 | quic::QuicStreamOffset offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5986 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1, &offset)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5987 | socket_data.AddWrite(SYNCHRONOUS, ERR_NO_BUFFER_SPACE); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 5988 | socket_data.AddWrite(SYNCHRONOUS, |
| 5989 | ConstructClientRequestHeadersPacket( |
| 5990 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 5991 | GetRequestHeaders("GET", "https", "/"), &offset)); |
| 5992 | socket_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 5993 | 1, GetNthClientInitiatedStreamId(0), false, |
| 5994 | false, GetResponseHeaders("200 OK"))); |
| 5995 | socket_data.AddRead( |
| 5996 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 5997 | false, true, 0, "hello!")); |
| 5998 | socket_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 5999 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Renjie | ba55fae | 2018-09-20 03:05:16 | [diff] [blame] | 6000 | socket_data.AddWrite( |
| 6001 | SYNCHRONOUS, client_maker_.MakeAckAndConnectionClosePacket( |
| 6002 | 4, false, quic::QuicTime::Delta::FromMilliseconds(0), 2, |
| 6003 | 1, 1, quic::QUIC_CONNECTION_CANCELLED, "net error")); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6004 | |
| 6005 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 6006 | |
| 6007 | CreateSession(); |
| 6008 | |
| 6009 | SendRequestAndExpectQuicResponse("hello!"); |
| 6010 | session_.reset(); |
| 6011 | } |
| 6012 | |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6013 | TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterAsyncNoBufferSpace) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 6014 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6015 | session_params_.origins_to_force_quic_on.insert( |
| 6016 | HostPortPair::FromString("mail.example.org:443")); |
| 6017 | |
| 6018 | MockQuicData socket_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6019 | quic::QuicStreamOffset offset = 0; |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6020 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6021 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1, &offset)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6022 | for (int i = 0; i < 13; ++i) { // 12 retries then one final failure. |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6023 | socket_data.AddWrite(ASYNC, ERR_NO_BUFFER_SPACE); |
| 6024 | } |
| 6025 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 6026 | |
| 6027 | CreateSession(); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6028 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| 6029 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 6030 | QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(), |
| 6031 | quic_task_runner_.get()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6032 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6033 | quic::QuicTime start = clock_.Now(); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6034 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 6035 | TestCompletionCallback callback; |
| 6036 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 6037 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6038 | while (!callback.have_result()) { |
| 6039 | base::RunLoop().RunUntilIdle(); |
| 6040 | quic_task_runner_->RunUntilIdle(); |
| 6041 | } |
| 6042 | ASSERT_TRUE(callback.have_result()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6043 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6044 | EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 6045 | EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 6046 | // Backoff should take between 4 - 5 seconds. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6047 | EXPECT_TRUE(clock_.Now() - start > quic::QuicTime::Delta::FromSeconds(4)); |
| 6048 | EXPECT_TRUE(clock_.Now() - start < quic::QuicTime::Delta::FromSeconds(5)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6049 | } |
| 6050 | |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6051 | TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterSynchronousNoBufferSpace) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 6052 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6053 | session_params_.origins_to_force_quic_on.insert( |
| 6054 | HostPortPair::FromString("mail.example.org:443")); |
| 6055 | |
| 6056 | MockQuicData socket_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6057 | quic::QuicStreamOffset offset = 0; |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6058 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6059 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1, &offset)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6060 | for (int i = 0; i < 13; ++i) { // 12 retries then one final failure. |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6061 | socket_data.AddWrite(ASYNC, ERR_NO_BUFFER_SPACE); |
| 6062 | } |
| 6063 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 6064 | |
| 6065 | CreateSession(); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6066 | // Use a TestTaskRunner to avoid waiting in real time for timeouts. |
| 6067 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 6068 | QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(), |
| 6069 | quic_task_runner_.get()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6070 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6071 | quic::QuicTime start = clock_.Now(); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6072 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 6073 | TestCompletionCallback callback; |
| 6074 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 6075 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6076 | while (!callback.have_result()) { |
| 6077 | base::RunLoop().RunUntilIdle(); |
| 6078 | quic_task_runner_->RunUntilIdle(); |
| 6079 | } |
| 6080 | ASSERT_TRUE(callback.have_result()); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6081 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
Ryan Hamilton | 9edcf1a | 2017-11-22 05:55:17 | [diff] [blame] | 6082 | EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 6083 | EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 6084 | // Backoff should take between 4 - 5 seconds. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6085 | EXPECT_TRUE(clock_.Now() - start > quic::QuicTime::Delta::FromSeconds(4)); |
| 6086 | EXPECT_TRUE(clock_.Now() - start < quic::QuicTime::Delta::FromSeconds(5)); |
Ryan Hamilton | 4b357453 | 2017-10-30 20:17:25 | [diff] [blame] | 6087 | } |
| 6088 | |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 6089 | TEST_P(QuicNetworkTransactionTest, NoMigrationForMsgTooBig) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 6090 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 6091 | session_params_.origins_to_force_quic_on.insert( |
| 6092 | HostPortPair::FromString("mail.example.org:443")); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6093 | const quic::QuicString error_details = |
| 6094 | quic::QuicStrCat("Write failed with error: ", ERR_MSG_TOO_BIG, " (", |
| 6095 | strerror(ERR_MSG_TOO_BIG), ")"); |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 6096 | |
| 6097 | MockQuicData socket_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6098 | quic::QuicStreamOffset offset = 0; |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 6099 | socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6100 | socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1, &offset)); |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 6101 | socket_data.AddWrite(SYNCHRONOUS, ERR_MSG_TOO_BIG); |
| 6102 | // Connection close packet will be sent for MSG_TOO_BIG. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6103 | socket_data.AddWrite( |
| 6104 | SYNCHRONOUS, client_maker_.MakeConnectionClosePacket( |
| 6105 | 3, true, quic::QUIC_PACKET_WRITE_ERROR, error_details)); |
Cherie Shi | 7596de63 | 2018-02-22 07:28:18 | [diff] [blame] | 6106 | socket_data.AddSocketDataToFactory(&socket_factory_); |
| 6107 | |
| 6108 | CreateSession(); |
| 6109 | |
| 6110 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 6111 | TestCompletionCallback callback; |
| 6112 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 6113 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 6114 | base::RunLoop().RunUntilIdle(); |
| 6115 | ASSERT_TRUE(callback.have_result()); |
| 6116 | EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 6117 | EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 6118 | EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 6119 | } |
| 6120 | |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 6121 | // Adds coverage to catch regression such as https://crbug.com/622043 |
| 6122 | TEST_P(QuicNetworkTransactionTest, QuicServerPush) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6123 | session_params_.origins_to_force_quic_on.insert( |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 6124 | HostPortPair::FromString("mail.example.org:443")); |
| 6125 | |
| 6126 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6127 | quic::QuicStreamOffset header_stream_offset = 0; |
| 6128 | quic::QuicPacketNumber client_packet_number = 1; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6129 | mock_quic_data.AddWrite( |
| 6130 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++, |
| 6131 | &header_stream_offset)); |
| 6132 | mock_quic_data.AddWrite( |
| 6133 | SYNCHRONOUS, |
| 6134 | ConstructClientRequestHeadersPacket( |
| 6135 | client_packet_number++, GetNthClientInitiatedStreamId(0), true, true, |
| 6136 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6137 | quic::QuicStreamOffset server_header_offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6138 | mock_quic_data.AddRead( |
| 6139 | ASYNC, |
| 6140 | ConstructServerPushPromisePacket( |
| 6141 | 1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0), |
| 6142 | false, GetRequestHeaders("GET", "https", "/pushed.jpg"), |
| 6143 | &server_header_offset, &server_maker_)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6144 | if (client_headers_include_h2_stream_dependency_ && |
Zhongyi Shi | 7b4f22b | 2018-08-23 17:22:26 | [diff] [blame] | 6145 | version_ >= quic::QUIC_VERSION_43) { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6146 | mock_quic_data.AddWrite( |
| 6147 | SYNCHRONOUS, |
| 6148 | ConstructClientPriorityPacket(client_packet_number++, false, |
| 6149 | GetNthServerInitiatedStreamId(0), |
| 6150 | GetNthClientInitiatedStreamId(0), |
| 6151 | DEFAULT_PRIORITY, &header_stream_offset)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6152 | } |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6153 | mock_quic_data.AddRead( |
| 6154 | ASYNC, ConstructServerResponseHeadersPacket( |
| 6155 | 2, GetNthClientInitiatedStreamId(0), false, false, |
| 6156 | GetResponseHeaders("200 OK"), &server_header_offset)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6157 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6158 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
| 6159 | mock_quic_data.AddRead( |
| 6160 | ASYNC, ConstructServerResponseHeadersPacket( |
| 6161 | 3, GetNthServerInitiatedStreamId(0), false, false, |
| 6162 | GetResponseHeaders("200 OK"), &server_header_offset)); |
| 6163 | mock_quic_data.AddRead( |
| 6164 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(0), |
| 6165 | false, true, 0, "hello!")); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6166 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6167 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 4, 3, 1)); |
| 6168 | mock_quic_data.AddRead( |
| 6169 | ASYNC, ConstructServerDataPacket(5, GetNthServerInitiatedStreamId(0), |
| 6170 | false, true, 0, "and hello!")); |
| 6171 | mock_quic_data.AddWrite( |
| 6172 | SYNCHRONOUS, ConstructClientAckAndRstPacket( |
| 6173 | client_packet_number++, GetNthServerInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6174 | quic::QUIC_RST_ACKNOWLEDGEMENT, 5, 5, 1)); |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 6175 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6176 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6177 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6178 | |
| 6179 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 6180 | // the alternate-protocol job will "win". |
| 6181 | AddHangingNonAlternateProtocolSocketData(); |
| 6182 | |
| 6183 | CreateSession(); |
| 6184 | |
| 6185 | // PUSH_PROMISE handling in the http layer gets exercised here. |
| 6186 | SendRequestAndExpectQuicResponse("hello!"); |
| 6187 | |
| 6188 | request_.url = GURL("https://mail.example.org/pushed.jpg"); |
| 6189 | SendRequestAndExpectQuicResponse("and hello!"); |
| 6190 | |
| 6191 | // Check that the NetLog was filled reasonably. |
| 6192 | TestNetLogEntry::List entries; |
| 6193 | net_log_.GetEntries(&entries); |
| 6194 | EXPECT_LT(0u, entries.size()); |
| 6195 | |
| 6196 | // Check that we logged a QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM |
| 6197 | int pos = ExpectLogContainsSomewhere( |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 6198 | entries, 0, NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM, |
| 6199 | NetLogEventPhase::NONE); |
ckrasic | 769733c | 2016-06-30 00:42:13 | [diff] [blame] | 6200 | EXPECT_LT(0, pos); |
| 6201 | } |
| 6202 | |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6203 | // Regression test for http://crbug.com/719461 in which a promised stream |
| 6204 | // is closed before the pushed headers arrive, but after the connection |
| 6205 | // is closed and before the callbacks are executed. |
| 6206 | TEST_P(QuicNetworkTransactionTest, CancelServerPushAfterConnectionClose) { |
Ryan Hamilton | b3827e88 | 2018-03-27 03:07:48 | [diff] [blame] | 6207 | session_params_.retry_without_alt_svc_on_quic_errors = false; |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6208 | session_params_.origins_to_force_quic_on.insert( |
| 6209 | HostPortPair::FromString("mail.example.org:443")); |
| 6210 | |
| 6211 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6212 | quic::QuicStreamOffset header_stream_offset = 0; |
| 6213 | quic::QuicPacketNumber client_packet_number = 1; |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6214 | // Initial SETTINGS frame. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6215 | mock_quic_data.AddWrite( |
| 6216 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++, |
| 6217 | &header_stream_offset)); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6218 | // First request: GET https://mail.example.org/ |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6219 | mock_quic_data.AddWrite( |
| 6220 | SYNCHRONOUS, |
| 6221 | ConstructClientRequestHeadersPacket( |
| 6222 | client_packet_number++, GetNthClientInitiatedStreamId(0), true, true, |
| 6223 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6224 | quic::QuicStreamOffset server_header_offset = 0; |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6225 | // Server promise for: https://mail.example.org/pushed.jpg |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6226 | mock_quic_data.AddRead( |
| 6227 | ASYNC, |
| 6228 | ConstructServerPushPromisePacket( |
| 6229 | 1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0), |
| 6230 | false, GetRequestHeaders("GET", "https", "/pushed.jpg"), |
| 6231 | &server_header_offset, &server_maker_)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6232 | if (client_headers_include_h2_stream_dependency_ && |
Zhongyi Shi | 7b4f22b | 2018-08-23 17:22:26 | [diff] [blame] | 6233 | version_ >= quic::QUIC_VERSION_43) { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6234 | mock_quic_data.AddWrite( |
| 6235 | SYNCHRONOUS, |
| 6236 | ConstructClientPriorityPacket(client_packet_number++, false, |
| 6237 | GetNthServerInitiatedStreamId(0), |
| 6238 | GetNthClientInitiatedStreamId(0), |
| 6239 | DEFAULT_PRIORITY, &header_stream_offset)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6240 | } |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6241 | // Response headers for first request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6242 | mock_quic_data.AddRead( |
| 6243 | ASYNC, ConstructServerResponseHeadersPacket( |
| 6244 | 2, GetNthClientInitiatedStreamId(0), false, false, |
| 6245 | GetResponseHeaders("200 OK"), &server_header_offset)); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6246 | // Client ACKs the response headers. |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6247 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6248 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6249 | // Response body for first request. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6250 | mock_quic_data.AddRead( |
| 6251 | ASYNC, ConstructServerDataPacket(3, GetNthClientInitiatedStreamId(0), |
| 6252 | false, true, 0, "hello!")); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6253 | // Write error for the third request. |
| 6254 | mock_quic_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
| 6255 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6256 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6257 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6258 | |
| 6259 | CreateSession(); |
| 6260 | |
| 6261 | // Send a request which triggers a push promise from the server. |
| 6262 | SendRequestAndExpectQuicResponse("hello!"); |
| 6263 | |
| 6264 | // Start a push transaction that will be cancelled after the connection |
| 6265 | // is closed, but before the callback is executed. |
| 6266 | request_.url = GURL("https://mail.example.org/pushed.jpg"); |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 6267 | auto trans2 = std::make_unique<HttpNetworkTransaction>(DEFAULT_PRIORITY, |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6268 | session_.get()); |
| 6269 | TestCompletionCallback callback2; |
| 6270 | int rv = trans2->Start(&request_, callback2.callback(), net_log_.bound()); |
| 6271 | EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| 6272 | base::RunLoop().RunUntilIdle(); |
| 6273 | |
| 6274 | // Cause the connection to close on a write error. |
| 6275 | HttpRequestInfo request3; |
| 6276 | request3.method = "GET"; |
| 6277 | request3.url = GURL("https://mail.example.org/"); |
| 6278 | request3.load_flags = 0; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 6279 | request3.traffic_annotation = |
| 6280 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
rch | 56ec40a | 2017-06-23 14:48:44 | [diff] [blame] | 6281 | HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session_.get()); |
| 6282 | TestCompletionCallback callback3; |
| 6283 | EXPECT_THAT(trans3.Start(&request3, callback3.callback(), net_log_.bound()), |
| 6284 | IsError(ERR_IO_PENDING)); |
| 6285 | |
| 6286 | base::RunLoop().RunUntilIdle(); |
| 6287 | |
| 6288 | // When |trans2| is destroyed, the underlying stream will be closed. |
| 6289 | EXPECT_FALSE(callback2.have_result()); |
| 6290 | trans2 = nullptr; |
| 6291 | |
| 6292 | EXPECT_THAT(callback3.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR)); |
| 6293 | } |
| 6294 | |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 6295 | TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6296 | session_params_.origins_to_force_quic_on.insert( |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 6297 | HostPortPair::FromString("mail.example.org:443")); |
| 6298 | |
| 6299 | MockQuicData mock_quic_data; |
| 6300 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6301 | quic::QuicStreamOffset offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6302 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6303 | ConstructInitialSettingsPacket(1, &offset)); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 6304 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6305 | mock_quic_data.AddWrite( |
| 6306 | SYNCHRONOUS, |
| 6307 | ConstructClientRequestHeadersAndDataFramesPacket( |
| 6308 | 2, GetNthClientInitiatedStreamId(0), true, true, DEFAULT_PRIORITY, |
| 6309 | GetRequestHeaders("POST", "https", "/"), 0, &offset, nullptr, {"1"})); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 6310 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6311 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 6312 | 1, GetNthClientInitiatedStreamId(0), false, |
| 6313 | false, GetResponseHeaders("200 OK"))); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 6314 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6315 | mock_quic_data.AddRead( |
| 6316 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 6317 | false, true, 0, "hello!")); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 6318 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6319 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
ckrasic | da193a8 | 2016-07-09 00:39:36 | [diff] [blame] | 6320 | |
| 6321 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6322 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6323 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6324 | |
| 6325 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 6326 | // the alternate-protocol job will "win". |
| 6327 | AddHangingNonAlternateProtocolSocketData(); |
| 6328 | |
| 6329 | CreateSession(); |
| 6330 | request_.method = "POST"; |
| 6331 | ChunkedUploadDataStream upload_data(0); |
| 6332 | upload_data.AppendData("1", 1, true); |
| 6333 | |
| 6334 | request_.upload_data_stream = &upload_data; |
| 6335 | |
| 6336 | SendRequestAndExpectQuicResponse("hello!"); |
| 6337 | } |
| 6338 | |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6339 | class QuicURLRequestContext : public URLRequestContext { |
| 6340 | public: |
| 6341 | QuicURLRequestContext(std::unique_ptr<HttpNetworkSession> session, |
| 6342 | MockClientSocketFactory* socket_factory) |
| 6343 | : storage_(this) { |
| 6344 | socket_factory_ = socket_factory; |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 6345 | storage_.set_host_resolver(std::make_unique<MockHostResolver>()); |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6346 | storage_.set_cert_verifier(std::make_unique<MockCertVerifier>()); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6347 | storage_.set_transport_security_state( |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6348 | std::make_unique<TransportSecurityState>()); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6349 | storage_.set_proxy_resolution_service( |
| 6350 | ProxyResolutionService::CreateDirect()); |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 6351 | storage_.set_ssl_config_service( |
| 6352 | std::make_unique<SSLConfigServiceDefaults>()); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6353 | storage_.set_http_auth_handler_factory( |
| 6354 | HttpAuthHandlerFactory::CreateDefault(host_resolver())); |
| 6355 | storage_.set_http_server_properties( |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 6356 | std::make_unique<HttpServerPropertiesImpl>()); |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6357 | storage_.set_job_factory(std::make_unique<URLRequestJobFactoryImpl>()); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6358 | storage_.set_http_network_session(std::move(session)); |
Bence Béky | 8f9d7d395 | 2017-10-09 19:58:04 | [diff] [blame] | 6359 | storage_.set_http_transaction_factory(std::make_unique<HttpCache>( |
| 6360 | storage_.http_network_session(), HttpCache::DefaultBackend::InMemory(0), |
| 6361 | false)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6362 | } |
| 6363 | |
| 6364 | ~QuicURLRequestContext() override { AssertNoURLRequests(); } |
| 6365 | |
| 6366 | MockClientSocketFactory& socket_factory() { return *socket_factory_; } |
| 6367 | |
| 6368 | private: |
| 6369 | MockClientSocketFactory* socket_factory_; |
| 6370 | URLRequestContextStorage storage_; |
| 6371 | }; |
| 6372 | |
| 6373 | TEST_P(QuicNetworkTransactionTest, RawHeaderSizeSuccessfullRequest) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6374 | session_params_.origins_to_force_quic_on.insert( |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6375 | HostPortPair::FromString("mail.example.org:443")); |
| 6376 | |
| 6377 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6378 | quic::QuicStreamOffset header_stream_offset = 0; |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 6379 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6380 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6381 | spdy::SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6382 | headers["user-agent"] = ""; |
| 6383 | headers["accept-encoding"] = "gzip, deflate"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6384 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6385 | ConstructClientRequestHeadersPacket( |
| 6386 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 6387 | std::move(headers), &header_stream_offset)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6388 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6389 | quic::QuicStreamOffset expected_raw_header_response_size = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6390 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 6391 | 1, GetNthClientInitiatedStreamId(0), false, |
| 6392 | false, GetResponseHeaders("200 OK"), |
| 6393 | &expected_raw_header_response_size)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6394 | |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6395 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6396 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 6397 | false, true, 0, "Main Resource Data")); |
| 6398 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6399 | |
| 6400 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6401 | |
| 6402 | CreateSession(); |
| 6403 | |
| 6404 | TestDelegate delegate; |
| 6405 | QuicURLRequestContext quic_url_request_context(std::move(session_), |
| 6406 | &socket_factory_); |
| 6407 | |
| 6408 | mock_quic_data.AddSocketDataToFactory( |
| 6409 | &quic_url_request_context.socket_factory()); |
| 6410 | TestNetworkDelegate network_delegate; |
| 6411 | quic_url_request_context.set_network_delegate(&network_delegate); |
| 6412 | |
| 6413 | std::unique_ptr<URLRequest> request(quic_url_request_context.CreateRequest( |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 6414 | GURL("https://mail.example.org/"), DEFAULT_PRIORITY, &delegate, |
| 6415 | TRAFFIC_ANNOTATION_FOR_TESTS)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6416 | quic_url_request_context.socket_factory().AddSSLSocketDataProvider( |
| 6417 | &ssl_data_); |
| 6418 | |
| 6419 | request->Start(); |
Wez | 2a31b22 | 2018-06-07 22:07:15 | [diff] [blame] | 6420 | delegate.RunUntilComplete(); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6421 | |
| 6422 | EXPECT_LT(0, request->GetTotalSentBytes()); |
| 6423 | EXPECT_LT(0, request->GetTotalReceivedBytes()); |
| 6424 | EXPECT_EQ(network_delegate.total_network_bytes_sent(), |
| 6425 | request->GetTotalSentBytes()); |
| 6426 | EXPECT_EQ(network_delegate.total_network_bytes_received(), |
| 6427 | request->GetTotalReceivedBytes()); |
| 6428 | EXPECT_EQ(static_cast<int>(expected_raw_header_response_size), |
| 6429 | request->raw_header_size()); |
Wez | 0e71711 | 2018-06-18 23:09:22 | [diff] [blame] | 6430 | |
| 6431 | // Pump the message loop to allow all data to be consumed. |
| 6432 | base::RunLoop().RunUntilIdle(); |
| 6433 | |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6434 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 6435 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 6436 | } |
| 6437 | |
| 6438 | TEST_P(QuicNetworkTransactionTest, RawHeaderSizeSuccessfullPushHeadersFirst) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6439 | session_params_.origins_to_force_quic_on.insert( |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6440 | HostPortPair::FromString("mail.example.org:443")); |
| 6441 | |
| 6442 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6443 | quic::QuicStreamOffset header_stream_offset = 0; |
| 6444 | quic::QuicPacketNumber client_packet_number = 1; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6445 | mock_quic_data.AddWrite( |
| 6446 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++, |
| 6447 | &header_stream_offset)); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6448 | spdy::SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6449 | headers["user-agent"] = ""; |
| 6450 | headers["accept-encoding"] = "gzip, deflate"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6451 | mock_quic_data.AddWrite( |
| 6452 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 6453 | client_packet_number++, GetNthClientInitiatedStreamId(0), |
| 6454 | true, true, std::move(headers), &header_stream_offset)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6455 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6456 | quic::QuicStreamOffset server_header_offset = 0; |
| 6457 | quic::QuicStreamOffset expected_raw_header_response_size = 0; |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6458 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6459 | mock_quic_data.AddRead( |
| 6460 | ASYNC, |
| 6461 | ConstructServerPushPromisePacket( |
| 6462 | 1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0), |
| 6463 | false, GetRequestHeaders("GET", "https", "/pushed.jpg"), |
| 6464 | &server_header_offset, &server_maker_)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6465 | |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6466 | if (client_headers_include_h2_stream_dependency_ && |
Zhongyi Shi | 7b4f22b | 2018-08-23 17:22:26 | [diff] [blame] | 6467 | version_ >= quic::QUIC_VERSION_43) { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6468 | mock_quic_data.AddWrite( |
| 6469 | SYNCHRONOUS, |
| 6470 | ConstructClientPriorityPacket(client_packet_number++, false, |
| 6471 | GetNthServerInitiatedStreamId(0), |
| 6472 | GetNthClientInitiatedStreamId(0), |
| 6473 | DEFAULT_PRIORITY, &header_stream_offset)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6474 | } |
| 6475 | |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6476 | expected_raw_header_response_size = server_header_offset; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6477 | mock_quic_data.AddRead( |
| 6478 | ASYNC, ConstructServerResponseHeadersPacket( |
| 6479 | 2, GetNthClientInitiatedStreamId(0), false, false, |
| 6480 | GetResponseHeaders("200 OK"), &server_header_offset)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6481 | expected_raw_header_response_size = |
| 6482 | server_header_offset - expected_raw_header_response_size; |
| 6483 | |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6484 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6485 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6486 | |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6487 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6488 | ASYNC, ConstructServerResponseHeadersPacket( |
| 6489 | 3, GetNthServerInitiatedStreamId(0), false, false, |
| 6490 | GetResponseHeaders("200 OK"), &server_header_offset)); |
| 6491 | mock_quic_data.AddRead( |
| 6492 | ASYNC, ConstructServerDataPacket(4, GetNthServerInitiatedStreamId(0), |
| 6493 | false, true, 0, "Pushed Resource Data")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6494 | |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 6495 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6496 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 4, 3, 1)); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6497 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6498 | ASYNC, ConstructServerDataPacket(5, GetNthClientInitiatedStreamId(0), |
| 6499 | false, true, 0, "Main Resource Data")); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6500 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6501 | mock_quic_data.AddRead(ASYNC, ConstructServerConnectionClosePacket(6)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6502 | |
| 6503 | CreateSession(); |
| 6504 | |
| 6505 | TestDelegate delegate; |
| 6506 | QuicURLRequestContext quic_url_request_context(std::move(session_), |
| 6507 | &socket_factory_); |
| 6508 | |
| 6509 | mock_quic_data.AddSocketDataToFactory( |
| 6510 | &quic_url_request_context.socket_factory()); |
| 6511 | TestNetworkDelegate network_delegate; |
| 6512 | quic_url_request_context.set_network_delegate(&network_delegate); |
| 6513 | |
| 6514 | std::unique_ptr<URLRequest> request(quic_url_request_context.CreateRequest( |
rhalavati | 9ebaba7e | 2017-04-27 06:16:29 | [diff] [blame] | 6515 | GURL("https://mail.example.org/"), DEFAULT_PRIORITY, &delegate, |
| 6516 | TRAFFIC_ANNOTATION_FOR_TESTS)); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6517 | quic_url_request_context.socket_factory().AddSSLSocketDataProvider( |
| 6518 | &ssl_data_); |
| 6519 | |
| 6520 | request->Start(); |
Wez | 2a31b22 | 2018-06-07 22:07:15 | [diff] [blame] | 6521 | delegate.RunUntilComplete(); |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6522 | |
| 6523 | EXPECT_LT(0, request->GetTotalSentBytes()); |
| 6524 | EXPECT_LT(0, request->GetTotalReceivedBytes()); |
| 6525 | EXPECT_EQ(network_delegate.total_network_bytes_sent(), |
| 6526 | request->GetTotalSentBytes()); |
| 6527 | EXPECT_EQ(network_delegate.total_network_bytes_received(), |
| 6528 | request->GetTotalReceivedBytes()); |
| 6529 | EXPECT_EQ(static_cast<int>(expected_raw_header_response_size), |
| 6530 | request->raw_header_size()); |
Wez | 0e71711 | 2018-06-18 23:09:22 | [diff] [blame] | 6531 | |
| 6532 | // Pump the message loop to allow all data to be consumed. |
| 6533 | base::RunLoop().RunUntilIdle(); |
| 6534 | |
allada | 71b2efb | 2016-09-09 04:57:48 | [diff] [blame] | 6535 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 6536 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 6537 | } |
| 6538 | |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6539 | TEST_P(QuicNetworkTransactionTest, HostInWhitelist) { |
| 6540 | session_params_.quic_host_whitelist.insert("mail.example.org"); |
| 6541 | |
| 6542 | MockRead http_reads[] = { |
| 6543 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 6544 | MockRead("hello world"), |
| 6545 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 6546 | MockRead(ASYNC, OK)}; |
| 6547 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 6548 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6549 | socket_factory_.AddSocketDataProvider(&http_data); |
| 6550 | AddCertificate(&ssl_data_); |
| 6551 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6552 | |
| 6553 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6554 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6555 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6556 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 6557 | mock_quic_data.AddWrite( |
| 6558 | SYNCHRONOUS, |
| 6559 | ConstructClientRequestHeadersPacket( |
| 6560 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 6561 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
| 6562 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 6563 | 1, GetNthClientInitiatedStreamId(0), false, |
| 6564 | false, GetResponseHeaders("200 OK"))); |
| 6565 | mock_quic_data.AddRead( |
| 6566 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 6567 | false, true, 0, "hello!")); |
| 6568 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1)); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6569 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6570 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6571 | |
| 6572 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6573 | |
| 6574 | AddHangingNonAlternateProtocolSocketData(); |
| 6575 | CreateSession(); |
| 6576 | |
| 6577 | SendRequestAndExpectHttpResponse("hello world"); |
| 6578 | SendRequestAndExpectQuicResponse("hello!"); |
| 6579 | } |
| 6580 | |
| 6581 | TEST_P(QuicNetworkTransactionTest, HostNotInWhitelist) { |
| 6582 | session_params_.quic_host_whitelist.insert("mail.example.com"); |
| 6583 | |
| 6584 | MockRead http_reads[] = { |
| 6585 | MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
| 6586 | MockRead("hello world"), |
| 6587 | MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
| 6588 | MockRead(ASYNC, OK)}; |
| 6589 | |
Ryan Sleevi | b8d7ea0 | 2018-05-07 20:01:01 | [diff] [blame] | 6590 | StaticSocketDataProvider http_data(http_reads, base::span<MockWrite>()); |
Yixin Wang | 10f477ed | 2017-11-21 04:20:20 | [diff] [blame] | 6591 | socket_factory_.AddSocketDataProvider(&http_data); |
| 6592 | AddCertificate(&ssl_data_); |
| 6593 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6594 | socket_factory_.AddSocketDataProvider(&http_data); |
| 6595 | AddCertificate(&ssl_data_); |
| 6596 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6597 | |
| 6598 | AddHangingNonAlternateProtocolSocketData(); |
| 6599 | CreateSession(); |
| 6600 | |
| 6601 | SendRequestAndExpectHttpResponse("hello world"); |
| 6602 | SendRequestAndExpectHttpResponse("hello world"); |
| 6603 | } |
| 6604 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6605 | class QuicNetworkTransactionWithDestinationTest |
| 6606 | : public PlatformTest, |
Bence Béky | 98447b1 | 2018-05-08 03:14:01 | [diff] [blame] | 6607 | public ::testing::WithParamInterface<PoolingTestParams>, |
| 6608 | public WithScopedTaskEnvironment { |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6609 | protected: |
| 6610 | QuicNetworkTransactionWithDestinationTest() |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 6611 | : version_(GetParam().version), |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6612 | client_headers_include_h2_stream_dependency_( |
| 6613 | GetParam().client_headers_include_h2_stream_dependency), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6614 | supported_versions_(quic::test::SupportedTransportVersions(version_)), |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6615 | destination_type_(GetParam().destination_type), |
| 6616 | cert_transparency_verifier_(new MultiLogCTVerifier()), |
| 6617 | ssl_config_service_(new SSLConfigServiceDefaults), |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6618 | proxy_resolution_service_(ProxyResolutionService::CreateDirect()), |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6619 | auth_handler_factory_( |
| 6620 | HttpAuthHandlerFactory::CreateDefault(&host_resolver_)), |
| 6621 | random_generator_(0), |
| 6622 | ssl_data_(ASYNC, OK) {} |
| 6623 | |
| 6624 | void SetUp() override { |
| 6625 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 6626 | base::RunLoop().RunUntilIdle(); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6627 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6628 | HttpNetworkSession::Params session_params; |
| 6629 | session_params.enable_quic = true; |
Ryan Hamilton | c84473f | 2017-11-23 03:18:34 | [diff] [blame] | 6630 | session_params.quic_allow_remote_alt_svc = true; |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 6631 | session_params.quic_supported_versions = supported_versions_; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6632 | session_params.quic_headers_include_h2_stream_dependency = |
| 6633 | client_headers_include_h2_stream_dependency_; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6634 | |
| 6635 | HttpNetworkSession::Context session_context; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6636 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6637 | clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20)); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6638 | session_context.quic_clock = &clock_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6639 | |
| 6640 | crypto_client_stream_factory_.set_handshake_mode( |
Ryan Hamilton | 9835e66 | 2018-08-02 05:36:27 | [diff] [blame] | 6641 | MockCryptoClientStream::CONFIRM_HANDSHAKE); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6642 | session_context.quic_crypto_client_stream_factory = |
| 6643 | &crypto_client_stream_factory_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6644 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6645 | session_context.quic_random = &random_generator_; |
| 6646 | session_context.client_socket_factory = &socket_factory_; |
| 6647 | session_context.host_resolver = &host_resolver_; |
| 6648 | session_context.cert_verifier = &cert_verifier_; |
| 6649 | session_context.transport_security_state = &transport_security_state_; |
| 6650 | session_context.cert_transparency_verifier = |
| 6651 | cert_transparency_verifier_.get(); |
| 6652 | session_context.ct_policy_enforcer = &ct_policy_enforcer_; |
| 6653 | session_context.socket_performance_watcher_factory = |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6654 | &test_socket_performance_watcher_factory_; |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6655 | session_context.ssl_config_service = ssl_config_service_.get(); |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6656 | session_context.proxy_resolution_service = proxy_resolution_service_.get(); |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6657 | session_context.http_auth_handler_factory = auth_handler_factory_.get(); |
| 6658 | session_context.http_server_properties = &http_server_properties_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6659 | |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 6660 | session_.reset(new HttpNetworkSession(session_params, session_context)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6661 | session_->quic_stream_factory()->set_require_confirmation(true); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6662 | } |
| 6663 | |
| 6664 | void TearDown() override { |
| 6665 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 6666 | // Empty the current queue. |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 6667 | base::RunLoop().RunUntilIdle(); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6668 | PlatformTest::TearDown(); |
| 6669 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
fdoray | 92e35a7 | 2016-06-10 15:54:55 | [diff] [blame] | 6670 | base::RunLoop().RunUntilIdle(); |
bnc | 525e175a | 2016-06-20 12:36:40 | [diff] [blame] | 6671 | session_.reset(); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6672 | } |
| 6673 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6674 | void SetQuicAlternativeService(const std::string& origin) { |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6675 | HostPortPair destination; |
| 6676 | switch (destination_type_) { |
| 6677 | case SAME_AS_FIRST: |
| 6678 | destination = HostPortPair(origin1_, 443); |
| 6679 | break; |
| 6680 | case SAME_AS_SECOND: |
| 6681 | destination = HostPortPair(origin2_, 443); |
| 6682 | break; |
| 6683 | case DIFFERENT: |
| 6684 | destination = HostPortPair(kDifferentHostname, 443); |
| 6685 | break; |
| 6686 | } |
bnc | 3472afd | 2016-11-17 15:27:21 | [diff] [blame] | 6687 | AlternativeService alternative_service(kProtoQUIC, destination); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6688 | base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6689 | http_server_properties_.SetQuicAlternativeService( |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6690 | url::SchemeHostPort("https", origin, 443), alternative_service, |
zhongyi | 86838d5 | 2017-06-30 01:19:44 | [diff] [blame] | 6691 | expiration, supported_versions_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6692 | } |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6693 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 6694 | ConstructClientRequestHeadersPacket(quic::QuicPacketNumber packet_number, |
| 6695 | quic::QuicStreamId stream_id, |
| 6696 | bool should_include_version, |
| 6697 | quic::QuicStreamOffset* offset, |
| 6698 | QuicTestPacketMaker* maker) { |
Yixin Wang | 7a3f1b8d | 2018-01-17 21:40:48 | [diff] [blame] | 6699 | return ConstructClientRequestHeadersPacket( |
| 6700 | packet_number, stream_id, should_include_version, 0, offset, maker); |
| 6701 | } |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6702 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6703 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 6704 | ConstructClientRequestHeadersPacket(quic::QuicPacketNumber packet_number, |
| 6705 | quic::QuicStreamId stream_id, |
| 6706 | bool should_include_version, |
| 6707 | quic::QuicStreamId parent_stream_id, |
| 6708 | quic::QuicStreamOffset* offset, |
| 6709 | QuicTestPacketMaker* maker) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6710 | spdy::SpdyPriority priority = |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6711 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6712 | spdy::SpdyHeaderBlock headers( |
| 6713 | maker->GetRequestHeaders("GET", "https", "/")); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6714 | return maker->MakeRequestHeadersPacketWithOffsetTracking( |
| 6715 | packet_number, stream_id, should_include_version, true, priority, |
Yixin Wang | 7a3f1b8d | 2018-01-17 21:40:48 | [diff] [blame] | 6716 | std::move(headers), parent_stream_id, offset); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6717 | } |
| 6718 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6719 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 6720 | ConstructClientRequestHeadersPacket(quic::QuicPacketNumber packet_number, |
| 6721 | quic::QuicStreamId stream_id, |
| 6722 | bool should_include_version, |
| 6723 | QuicTestPacketMaker* maker) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 6724 | return ConstructClientRequestHeadersPacket( |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6725 | packet_number, stream_id, should_include_version, nullptr, maker); |
| 6726 | } |
| 6727 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6728 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 6729 | ConstructServerResponseHeadersPacket(quic::QuicPacketNumber packet_number, |
| 6730 | quic::QuicStreamId stream_id, |
| 6731 | quic::QuicStreamOffset* offset, |
| 6732 | QuicTestPacketMaker* maker) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 6733 | spdy::SpdyHeaderBlock headers(maker->GetResponseHeaders("200 OK")); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6734 | return maker->MakeResponseHeadersPacketWithOffsetTracking( |
bnc | 086b39e1 | 2016-06-24 13:05:26 | [diff] [blame] | 6735 | packet_number, stream_id, false, false, std::move(headers), offset); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6736 | } |
| 6737 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6738 | std::unique_ptr<quic::QuicEncryptedPacket> |
| 6739 | ConstructServerResponseHeadersPacket(quic::QuicPacketNumber packet_number, |
| 6740 | quic::QuicStreamId stream_id, |
| 6741 | QuicTestPacketMaker* maker) { |
alyssar | 2adf3ac | 2016-05-03 17:12:58 | [diff] [blame] | 6742 | return ConstructServerResponseHeadersPacket(packet_number, stream_id, |
| 6743 | nullptr, maker); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6744 | } |
| 6745 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6746 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket( |
| 6747 | quic::QuicPacketNumber packet_number, |
| 6748 | quic::QuicStreamId stream_id, |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6749 | QuicTestPacketMaker* maker) { |
| 6750 | return maker->MakeDataPacket(packet_number, stream_id, false, true, 0, |
| 6751 | "hello"); |
| 6752 | } |
| 6753 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6754 | std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientAckPacket( |
| 6755 | quic::QuicPacketNumber packet_number, |
| 6756 | quic::QuicPacketNumber largest_received, |
| 6757 | quic::QuicPacketNumber smallest_received, |
| 6758 | quic::QuicPacketNumber least_unacked, |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6759 | QuicTestPacketMaker* maker) { |
| 6760 | return maker->MakeAckPacket(packet_number, largest_received, |
wangyix | 6444ffe | 2017-04-25 17:49:49 | [diff] [blame] | 6761 | smallest_received, least_unacked, true); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6762 | } |
| 6763 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6764 | std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket( |
| 6765 | quic::QuicPacketNumber packet_number, |
| 6766 | quic::QuicStreamOffset* offset, |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 6767 | QuicTestPacketMaker* maker) { |
rch | 5cb52246 | 2017-04-25 20:18:36 | [diff] [blame] | 6768 | return maker->MakeInitialSettingsPacket(packet_number, offset); |
fayang | 3bcb8b50 | 2016-12-07 21:44:37 | [diff] [blame] | 6769 | } |
| 6770 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6771 | void AddRefusedSocketData() { |
| 6772 | std::unique_ptr<StaticSocketDataProvider> refused_data( |
| 6773 | new StaticSocketDataProvider()); |
| 6774 | MockConnect refused_connect(SYNCHRONOUS, ERR_CONNECTION_REFUSED); |
| 6775 | refused_data->set_connect_data(refused_connect); |
| 6776 | socket_factory_.AddSocketDataProvider(refused_data.get()); |
| 6777 | static_socket_data_provider_vector_.push_back(std::move(refused_data)); |
| 6778 | } |
| 6779 | |
| 6780 | void AddHangingSocketData() { |
| 6781 | std::unique_ptr<StaticSocketDataProvider> hanging_data( |
| 6782 | new StaticSocketDataProvider()); |
| 6783 | MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING); |
| 6784 | hanging_data->set_connect_data(hanging_connect); |
| 6785 | socket_factory_.AddSocketDataProvider(hanging_data.get()); |
| 6786 | static_socket_data_provider_vector_.push_back(std::move(hanging_data)); |
| 6787 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 6788 | } |
| 6789 | |
| 6790 | bool AllDataConsumed() { |
| 6791 | for (const auto& socket_data_ptr : static_socket_data_provider_vector_) { |
| 6792 | if (!socket_data_ptr->AllReadDataConsumed() || |
| 6793 | !socket_data_ptr->AllWriteDataConsumed()) { |
| 6794 | return false; |
| 6795 | } |
| 6796 | } |
| 6797 | return true; |
| 6798 | } |
| 6799 | |
| 6800 | void SendRequestAndExpectQuicResponse(const std::string& host) { |
| 6801 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 6802 | HttpRequestInfo request; |
| 6803 | std::string url("https://"); |
| 6804 | url.append(host); |
| 6805 | request.url = GURL(url); |
| 6806 | request.load_flags = 0; |
| 6807 | request.method = "GET"; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 6808 | request.traffic_annotation = |
| 6809 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6810 | TestCompletionCallback callback; |
| 6811 | int rv = trans.Start(&request, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 6812 | EXPECT_THAT(callback.GetResult(rv), IsOk()); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6813 | |
| 6814 | std::string response_data; |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 6815 | ASSERT_THAT(ReadTransaction(&trans, &response_data), IsOk()); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6816 | EXPECT_EQ("hello", response_data); |
| 6817 | |
| 6818 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
| 6819 | ASSERT_TRUE(response != nullptr); |
| 6820 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 6821 | EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| 6822 | EXPECT_TRUE(response->was_fetched_via_spdy); |
bnc | 94c9284 | 2016-09-21 15:22:52 | [diff] [blame] | 6823 | EXPECT_TRUE(response->was_alpn_negotiated); |
bnc | 90be5dd78 | 2016-11-09 16:28:44 | [diff] [blame] | 6824 | EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_), |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6825 | response->connection_info); |
| 6826 | EXPECT_EQ(443, response->socket_address.port()); |
| 6827 | } |
| 6828 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6829 | quic::QuicStreamId GetNthClientInitiatedStreamId(int n) { |
| 6830 | return quic::test::GetNthClientInitiatedStreamId(version_, n); |
ckrasic | bf2f59c | 2017-05-04 23:54:36 | [diff] [blame] | 6831 | } |
| 6832 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6833 | quic::MockClock clock_; |
| 6834 | const quic::QuicTransportVersion version_; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6835 | const bool client_headers_include_h2_stream_dependency_; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6836 | quic::QuicTransportVersionVector supported_versions_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6837 | DestinationType destination_type_; |
| 6838 | std::string origin1_; |
| 6839 | std::string origin2_; |
| 6840 | std::unique_ptr<HttpNetworkSession> session_; |
| 6841 | MockClientSocketFactory socket_factory_; |
| 6842 | MockHostResolver host_resolver_; |
| 6843 | MockCertVerifier cert_verifier_; |
| 6844 | TransportSecurityState transport_security_state_; |
| 6845 | std::unique_ptr<CTVerifier> cert_transparency_verifier_; |
Ryan Sleevi | 8a9c9c1 | 2018-05-09 02:36:23 | [diff] [blame] | 6846 | DefaultCTPolicyEnforcer ct_policy_enforcer_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6847 | TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_; |
Ryan Sleevi | b8449e0 | 2018-07-15 04:31:07 | [diff] [blame] | 6848 | std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_; |
Lily Houghton | 8c2f97d | 2018-01-22 05:06:59 | [diff] [blame] | 6849 | std::unique_ptr<ProxyResolutionService> proxy_resolution_service_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6850 | std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6851 | quic::test::MockRandom random_generator_; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6852 | HttpServerPropertiesImpl http_server_properties_; |
| 6853 | BoundTestNetLog net_log_; |
| 6854 | MockCryptoClientStreamFactory crypto_client_stream_factory_; |
| 6855 | std::vector<std::unique_ptr<StaticSocketDataProvider>> |
| 6856 | static_socket_data_provider_vector_; |
| 6857 | SSLSocketDataProvider ssl_data_; |
| 6858 | }; |
| 6859 | |
Bence Béky | ce380cb | 2018-04-26 23:39:55 | [diff] [blame] | 6860 | INSTANTIATE_TEST_CASE_P(VersionIncludeStreamDependencySequence, |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6861 | QuicNetworkTransactionWithDestinationTest, |
| 6862 | ::testing::ValuesIn(GetPoolingTestParams())); |
| 6863 | |
| 6864 | // A single QUIC request fails because the certificate does not match the origin |
| 6865 | // hostname, regardless of whether it matches the alternative service hostname. |
| 6866 | TEST_P(QuicNetworkTransactionWithDestinationTest, InvalidCertificate) { |
| 6867 | if (destination_type_ == DIFFERENT) |
| 6868 | return; |
| 6869 | |
| 6870 | GURL url("https://mail.example.com/"); |
| 6871 | origin1_ = url.host(); |
| 6872 | |
| 6873 | // Not used for requests, but this provides a test case where the certificate |
| 6874 | // is valid for the hostname of the alternative service. |
| 6875 | origin2_ = "mail.example.org"; |
| 6876 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6877 | SetQuicAlternativeService(origin1_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6878 | |
| 6879 | scoped_refptr<X509Certificate> cert( |
| 6880 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 6881 | ASSERT_FALSE(cert->VerifyNameMatch(origin1_)); |
| 6882 | ASSERT_TRUE(cert->VerifyNameMatch(origin2_)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6883 | |
| 6884 | ProofVerifyDetailsChromium verify_details; |
| 6885 | verify_details.cert_verify_result.verified_cert = cert; |
| 6886 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 6887 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 6888 | |
| 6889 | MockQuicData mock_quic_data; |
| 6890 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
| 6891 | mock_quic_data.AddRead(ASYNC, 0); |
| 6892 | |
| 6893 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6894 | |
| 6895 | AddRefusedSocketData(); |
| 6896 | |
| 6897 | HttpRequestInfo request; |
| 6898 | request.url = url; |
Ramin Halavati | b5e433e6 | 2018-02-07 07:41:10 | [diff] [blame] | 6899 | request.traffic_annotation = |
| 6900 | net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6901 | |
| 6902 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 6903 | TestCompletionCallback callback; |
| 6904 | int rv = trans.Start(&request, callback.callback(), net_log_.bound()); |
robpercival | 214763f | 2016-07-01 23:27:01 | [diff] [blame] | 6905 | EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6906 | |
| 6907 | EXPECT_TRUE(AllDataConsumed()); |
| 6908 | } |
| 6909 | |
| 6910 | // First request opens QUIC session to alternative service. Second request |
| 6911 | // pools to it, because destination matches and certificate is valid, even |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6912 | // though quic::QuicServerId is different. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6913 | TEST_P(QuicNetworkTransactionWithDestinationTest, PoolIfCertificateValid) { |
| 6914 | origin1_ = "mail.example.org"; |
| 6915 | origin2_ = "news.example.org"; |
| 6916 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 6917 | SetQuicAlternativeService(origin1_); |
| 6918 | SetQuicAlternativeService(origin2_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6919 | |
| 6920 | scoped_refptr<X509Certificate> cert( |
| 6921 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 6922 | ASSERT_TRUE(cert->VerifyNameMatch(origin1_)); |
| 6923 | ASSERT_TRUE(cert->VerifyNameMatch(origin2_)); |
| 6924 | ASSERT_FALSE(cert->VerifyNameMatch(kDifferentHostname)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6925 | |
| 6926 | ProofVerifyDetailsChromium verify_details; |
| 6927 | verify_details.cert_verify_result.verified_cert = cert; |
| 6928 | verify_details.cert_verify_result.is_issued_by_known_root = true; |
| 6929 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 6930 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6931 | QuicTestPacketMaker client_maker( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6932 | version_, 0, &clock_, origin1_, quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6933 | client_headers_include_h2_stream_dependency_); |
| 6934 | QuicTestPacketMaker server_maker(version_, 0, &clock_, origin1_, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6935 | quic::Perspective::IS_SERVER, false); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6936 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 6937 | quic::QuicStreamOffset request_header_offset(0); |
| 6938 | quic::QuicStreamOffset response_header_offset(0); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6939 | |
| 6940 | MockQuicData mock_quic_data; |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6941 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6942 | SYNCHRONOUS, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6943 | ConstructInitialSettingsPacket(1, &request_header_offset, &client_maker)); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6944 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6945 | ConstructClientRequestHeadersPacket( |
| 6946 | 2, GetNthClientInitiatedStreamId(0), true, |
| 6947 | &request_header_offset, &client_maker)); |
| 6948 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 6949 | 1, GetNthClientInitiatedStreamId(0), |
| 6950 | &response_header_offset, &server_maker)); |
| 6951 | mock_quic_data.AddRead( |
| 6952 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 6953 | &server_maker)); |
| 6954 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6955 | ConstructClientAckPacket(3, 2, 1, 1, &client_maker)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6956 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 6957 | client_maker.set_hostname(origin2_); |
| 6958 | server_maker.set_hostname(origin2_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6959 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 6960 | mock_quic_data.AddWrite( |
| 6961 | SYNCHRONOUS, ConstructClientRequestHeadersPacket( |
| 6962 | 4, GetNthClientInitiatedStreamId(1), false, |
| 6963 | GetNthClientInitiatedStreamId(0), &request_header_offset, |
| 6964 | &client_maker)); |
| 6965 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 6966 | 3, GetNthClientInitiatedStreamId(1), |
| 6967 | &response_header_offset, &server_maker)); |
| 6968 | mock_quic_data.AddRead( |
| 6969 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(1), |
| 6970 | &server_maker)); |
| 6971 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 6972 | ConstructClientAckPacket(5, 4, 3, 1, &client_maker)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6973 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 6974 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 6975 | |
| 6976 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 6977 | |
| 6978 | AddHangingSocketData(); |
| 6979 | AddHangingSocketData(); |
| 6980 | |
Fan Yang | c9e00dc | 2018-10-09 14:17:56 | [diff] [blame^] | 6981 | scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_)); |
| 6982 | QuicStreamFactoryPeer::SetAlarmFactory( |
| 6983 | session_->quic_stream_factory(), |
| 6984 | std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(), |
| 6985 | &clock_)); |
| 6986 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6987 | SendRequestAndExpectQuicResponse(origin1_); |
| 6988 | SendRequestAndExpectQuicResponse(origin2_); |
| 6989 | |
| 6990 | EXPECT_TRUE(AllDataConsumed()); |
| 6991 | } |
| 6992 | |
| 6993 | // First request opens QUIC session to alternative service. Second request does |
| 6994 | // not pool to it, even though destination matches, because certificate is not |
| 6995 | // 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] | 6996 | // different quic::QuicServerId. |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 6997 | TEST_P(QuicNetworkTransactionWithDestinationTest, |
| 6998 | DoNotPoolIfCertificateInvalid) { |
| 6999 | origin1_ = "news.example.org"; |
| 7000 | origin2_ = "mail.example.com"; |
| 7001 | |
zhongyi | e537a00 | 2017-06-27 16:48:21 | [diff] [blame] | 7002 | SetQuicAlternativeService(origin1_); |
| 7003 | SetQuicAlternativeService(origin2_); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7004 | |
| 7005 | scoped_refptr<X509Certificate> cert1( |
| 7006 | ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 7007 | ASSERT_TRUE(cert1->VerifyNameMatch(origin1_)); |
| 7008 | ASSERT_FALSE(cert1->VerifyNameMatch(origin2_)); |
| 7009 | ASSERT_FALSE(cert1->VerifyNameMatch(kDifferentHostname)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7010 | |
| 7011 | scoped_refptr<X509Certificate> cert2( |
| 7012 | ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem")); |
Ryan Sleevi | def35f6 | 2018-01-23 21:12:24 | [diff] [blame] | 7013 | ASSERT_TRUE(cert2->VerifyNameMatch(origin2_)); |
| 7014 | ASSERT_FALSE(cert2->VerifyNameMatch(kDifferentHostname)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7015 | |
| 7016 | ProofVerifyDetailsChromium verify_details1; |
| 7017 | verify_details1.cert_verify_result.verified_cert = cert1; |
| 7018 | verify_details1.cert_verify_result.is_issued_by_known_root = true; |
| 7019 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1); |
| 7020 | |
| 7021 | ProofVerifyDetailsChromium verify_details2; |
| 7022 | verify_details2.cert_verify_result.verified_cert = cert2; |
| 7023 | verify_details2.cert_verify_result.is_issued_by_known_root = true; |
| 7024 | crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); |
| 7025 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 7026 | QuicTestPacketMaker client_maker1( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7027 | version_, 0, &clock_, origin1_, quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 7028 | client_headers_include_h2_stream_dependency_); |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 7029 | QuicTestPacketMaker server_maker1(version_, 0, &clock_, origin1_, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7030 | quic::Perspective::IS_SERVER, false); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7031 | |
| 7032 | MockQuicData mock_quic_data1; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7033 | quic::QuicStreamOffset header_stream_offset1 = 0; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7034 | mock_quic_data1.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7035 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset1, |
| 7036 | &client_maker1)); |
| 7037 | mock_quic_data1.AddWrite(SYNCHRONOUS, |
| 7038 | ConstructClientRequestHeadersPacket( |
| 7039 | 2, GetNthClientInitiatedStreamId(0), true, |
| 7040 | &header_stream_offset1, &client_maker1)); |
| 7041 | mock_quic_data1.AddRead( |
| 7042 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7043 | 1, GetNthClientInitiatedStreamId(0), &server_maker1)); |
| 7044 | mock_quic_data1.AddRead( |
| 7045 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 7046 | &server_maker1)); |
| 7047 | mock_quic_data1.AddWrite( |
| 7048 | SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1, &client_maker1)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7049 | mock_quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 7050 | mock_quic_data1.AddRead(ASYNC, 0); // EOF |
| 7051 | |
| 7052 | mock_quic_data1.AddSocketDataToFactory(&socket_factory_); |
| 7053 | |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 7054 | QuicTestPacketMaker client_maker2( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7055 | version_, 0, &clock_, origin2_, quic::Perspective::IS_CLIENT, |
Yixin Wang | 079ad54 | 2018-01-11 04:06:05 | [diff] [blame] | 7056 | client_headers_include_h2_stream_dependency_); |
rch | bf4c26d | 2017-04-16 23:17:55 | [diff] [blame] | 7057 | QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2_, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7058 | quic::Perspective::IS_SERVER, false); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7059 | |
| 7060 | MockQuicData mock_quic_data2; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7061 | quic::QuicStreamOffset header_stream_offset2 = 0; |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7062 | mock_quic_data2.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7063 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset2, |
| 7064 | &client_maker2)); |
| 7065 | mock_quic_data2.AddWrite(SYNCHRONOUS, |
| 7066 | ConstructClientRequestHeadersPacket( |
| 7067 | 2, GetNthClientInitiatedStreamId(0), true, |
| 7068 | &header_stream_offset2, &client_maker2)); |
| 7069 | mock_quic_data2.AddRead( |
| 7070 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7071 | 1, GetNthClientInitiatedStreamId(0), &server_maker2)); |
| 7072 | mock_quic_data2.AddRead( |
| 7073 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 7074 | &server_maker2)); |
| 7075 | mock_quic_data2.AddWrite( |
| 7076 | SYNCHRONOUS, ConstructClientAckPacket(3, 2, 1, 1, &client_maker2)); |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7077 | mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 7078 | mock_quic_data2.AddRead(ASYNC, 0); // EOF |
| 7079 | |
| 7080 | mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
| 7081 | |
bnc | 359ed2a | 2016-04-29 20:43:45 | [diff] [blame] | 7082 | SendRequestAndExpectQuicResponse(origin1_); |
| 7083 | SendRequestAndExpectQuicResponse(origin2_); |
| 7084 | |
| 7085 | EXPECT_TRUE(AllDataConsumed()); |
| 7086 | } |
| 7087 | |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 7088 | // crbug.com/705109 - this confirms that matching request with a body |
| 7089 | // triggers a crash (pre-fix). |
| 7090 | TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) { |
mmenke | 6ddfbea | 2017-05-31 21:48:41 | [diff] [blame] | 7091 | session_params_.origins_to_force_quic_on.insert( |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 7092 | HostPortPair::FromString("mail.example.org:443")); |
| 7093 | |
| 7094 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7095 | quic::QuicStreamOffset header_stream_offset = 0; |
| 7096 | quic::QuicPacketNumber client_packet_number = 1; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7097 | mock_quic_data.AddWrite( |
| 7098 | SYNCHRONOUS, ConstructInitialSettingsPacket(client_packet_number++, |
| 7099 | &header_stream_offset)); |
| 7100 | mock_quic_data.AddWrite( |
| 7101 | SYNCHRONOUS, |
| 7102 | ConstructClientRequestHeadersPacket( |
| 7103 | client_packet_number++, GetNthClientInitiatedStreamId(0), true, true, |
| 7104 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7105 | quic::QuicStreamOffset server_header_offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7106 | mock_quic_data.AddRead( |
| 7107 | ASYNC, |
| 7108 | ConstructServerPushPromisePacket( |
| 7109 | 1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0), |
| 7110 | false, GetRequestHeaders("GET", "https", "/pushed.jpg"), |
| 7111 | &server_header_offset, &server_maker_)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 7112 | if (client_headers_include_h2_stream_dependency_ && |
Zhongyi Shi | 7b4f22b | 2018-08-23 17:22:26 | [diff] [blame] | 7113 | version_ >= quic::QUIC_VERSION_43) { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7114 | mock_quic_data.AddWrite( |
| 7115 | SYNCHRONOUS, |
| 7116 | ConstructClientPriorityPacket(client_packet_number++, false, |
| 7117 | GetNthServerInitiatedStreamId(0), |
| 7118 | GetNthClientInitiatedStreamId(0), |
| 7119 | DEFAULT_PRIORITY, &header_stream_offset)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 7120 | } |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7121 | mock_quic_data.AddRead( |
| 7122 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7123 | 2, GetNthClientInitiatedStreamId(0), false, false, |
| 7124 | GetResponseHeaders("200 OK"), &server_header_offset)); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 7125 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7126 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 2, 1, 1)); |
| 7127 | mock_quic_data.AddRead( |
| 7128 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7129 | 3, GetNthServerInitiatedStreamId(0), false, false, |
| 7130 | GetResponseHeaders("200 OK"), &server_header_offset)); |
| 7131 | mock_quic_data.AddRead( |
| 7132 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(0), |
| 7133 | false, true, 0, "hello!")); |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 7134 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7135 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 4, 3, 1)); |
| 7136 | mock_quic_data.AddRead( |
| 7137 | ASYNC, ConstructServerDataPacket(5, GetNthServerInitiatedStreamId(0), |
| 7138 | false, true, 0, "and hello!")); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 7139 | |
| 7140 | // Because the matching request has a body, we will see the push |
| 7141 | // stream get cancelled, and the matching request go out on the |
| 7142 | // wire. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7143 | mock_quic_data.AddWrite( |
| 7144 | SYNCHRONOUS, ConstructClientAckAndRstPacket( |
| 7145 | client_packet_number++, GetNthServerInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7146 | quic::QUIC_STREAM_CANCELLED, 5, 5, 1)); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 7147 | const char kBody[] = "1"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7148 | mock_quic_data.AddWrite( |
| 7149 | SYNCHRONOUS, |
| 7150 | ConstructClientRequestHeadersAndDataFramesPacket( |
| 7151 | client_packet_number++, GetNthClientInitiatedStreamId(1), false, true, |
| 7152 | DEFAULT_PRIORITY, GetRequestHeaders("GET", "https", "/pushed.jpg"), |
| 7153 | GetNthServerInitiatedStreamId(0), &header_stream_offset, nullptr, |
| 7154 | {kBody})); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 7155 | |
| 7156 | // We see the same response as for the earlier pushed and cancelled |
| 7157 | // stream. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7158 | mock_quic_data.AddRead( |
| 7159 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7160 | 6, GetNthClientInitiatedStreamId(1), false, false, |
| 7161 | GetResponseHeaders("200 OK"), &server_header_offset)); |
| 7162 | mock_quic_data.AddRead( |
| 7163 | ASYNC, ConstructServerDataPacket(7, GetNthClientInitiatedStreamId(1), |
| 7164 | false, true, 0, "and hello!")); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 7165 | |
Yixin Wang | b470bc88 | 2018-02-15 18:43:57 | [diff] [blame] | 7166 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7167 | SYNCHRONOUS, ConstructClientAckPacket(client_packet_number++, 7, 6, 1)); |
ckrasic | dee3757 | 2017-04-06 22:42:27 | [diff] [blame] | 7168 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 7169 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 7170 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7171 | |
| 7172 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 7173 | // the alternate-protocol job will "win". |
| 7174 | AddHangingNonAlternateProtocolSocketData(); |
| 7175 | |
| 7176 | CreateSession(); |
| 7177 | |
| 7178 | // PUSH_PROMISE handling in the http layer gets exercised here. |
| 7179 | SendRequestAndExpectQuicResponse("hello!"); |
| 7180 | |
| 7181 | request_.url = GURL("https://mail.example.org/pushed.jpg"); |
| 7182 | ChunkedUploadDataStream upload_data(0); |
| 7183 | upload_data.AppendData("1", 1, true); |
| 7184 | request_.upload_data_stream = &upload_data; |
| 7185 | SendRequestAndExpectQuicResponse("and hello!"); |
| 7186 | } |
| 7187 | |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 7188 | // Regression test for https://crbug.com/797825: If pushed headers describe a |
| 7189 | // valid URL with empty hostname, then X509Certificate::VerifyHostname() must |
| 7190 | // not be called (otherwise a DCHECK fails). |
| 7191 | TEST_P(QuicNetworkTransactionTest, QuicServerPushWithEmptyHostname) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7192 | spdy::SpdyHeaderBlock pushed_request_headers; |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 7193 | pushed_request_headers[":authority"] = ""; |
| 7194 | pushed_request_headers[":method"] = "GET"; |
| 7195 | pushed_request_headers[":path"] = "/"; |
| 7196 | pushed_request_headers[":scheme"] = "nosuchscheme"; |
| 7197 | |
| 7198 | session_params_.origins_to_force_quic_on.insert( |
| 7199 | HostPortPair::FromString("mail.example.org:443")); |
| 7200 | |
| 7201 | MockQuicData mock_quic_data; |
| 7202 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7203 | quic::QuicStreamOffset header_stream_offset = 0; |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 7204 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7205 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 7206 | mock_quic_data.AddWrite( |
| 7207 | SYNCHRONOUS, |
| 7208 | ConstructClientRequestHeadersPacket( |
| 7209 | 2, GetNthClientInitiatedStreamId(0), true, true, |
| 7210 | GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 7211 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7212 | quic::QuicStreamOffset server_header_offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7213 | mock_quic_data.AddRead(ASYNC, ConstructServerPushPromisePacket( |
| 7214 | 1, GetNthClientInitiatedStreamId(0), |
| 7215 | GetNthServerInitiatedStreamId(0), false, |
| 7216 | std::move(pushed_request_headers), |
| 7217 | &server_header_offset, &server_maker_)); |
| 7218 | mock_quic_data.AddWrite( |
| 7219 | SYNCHRONOUS, ConstructClientRstPacket(3, GetNthServerInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7220 | quic::QUIC_INVALID_PROMISE_URL, 0)); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 7221 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7222 | mock_quic_data.AddRead( |
| 7223 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7224 | 2, GetNthClientInitiatedStreamId(0), false, false, |
| 7225 | GetResponseHeaders("200 OK"), &server_header_offset)); |
| 7226 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 2, 1, 1)); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 7227 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7228 | mock_quic_data.AddRead( |
| 7229 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7230 | 3, GetNthServerInitiatedStreamId(0), false, false, |
| 7231 | GetResponseHeaders("200 OK"), &server_header_offset)); |
| 7232 | mock_quic_data.AddRead( |
| 7233 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(0), |
| 7234 | false, true, 0, "hello!")); |
| 7235 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(5, 4, 3, 1)); |
Bence Béky | 7538a95 | 2018-02-01 16:59:52 | [diff] [blame] | 7236 | |
| 7237 | mock_quic_data.AddRead(ASYNC, 0); |
| 7238 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7239 | |
| 7240 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 7241 | // the alternate-protocol job will "win". |
| 7242 | AddHangingNonAlternateProtocolSocketData(); |
| 7243 | |
| 7244 | CreateSession(); |
| 7245 | |
| 7246 | // PUSH_PROMISE handling in the http layer gets exercised here. |
| 7247 | SendRequestAndExpectQuicResponse("hello!"); |
| 7248 | |
| 7249 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7250 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7251 | } |
| 7252 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7253 | // Performs an HTTPS/1.1 request over QUIC proxy tunnel. |
| 7254 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectHttpsServer) { |
| 7255 | session_params_.enable_quic = true; |
| 7256 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7257 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7258 | |
| 7259 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7260 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7261 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7262 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 7263 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7264 | ConstructClientRequestHeadersPacket( |
| 7265 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7266 | ConnectRequestHeaders("mail.example.org:443"), |
| 7267 | &header_stream_offset)); |
| 7268 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 7269 | 1, GetNthClientInitiatedStreamId(0), false, |
| 7270 | false, GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7271 | |
| 7272 | const char get_request[] = |
| 7273 | "GET / HTTP/1.1\r\n" |
| 7274 | "Host: mail.example.org\r\n" |
| 7275 | "Connection: keep-alive\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7276 | mock_quic_data.AddWrite( |
| 7277 | SYNCHRONOUS, ConstructClientAckAndDataPacket( |
| 7278 | 3, false, GetNthClientInitiatedStreamId(0), 1, 1, 1, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7279 | false, 0, quic::QuicStringPiece(get_request))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7280 | const char get_response[] = |
| 7281 | "HTTP/1.1 200 OK\r\n" |
| 7282 | "Content-Length: 10\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7283 | mock_quic_data.AddRead( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7284 | ASYNC, |
| 7285 | ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), false, |
| 7286 | false, 0, quic::QuicStringPiece(get_response))); |
| 7287 | |
| 7288 | mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerDataPacket( |
| 7289 | 3, GetNthClientInitiatedStreamId(0), |
| 7290 | false, false, strlen(get_response), |
| 7291 | quic::QuicStringPiece("0123456789"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7292 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7293 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7294 | |
| 7295 | mock_quic_data.AddWrite( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7296 | SYNCHRONOUS, ConstructClientRstPacket(5, GetNthClientInitiatedStreamId(0), |
| 7297 | quic::QUIC_STREAM_CANCELLED, |
| 7298 | strlen(get_request))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7299 | |
| 7300 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7301 | |
| 7302 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7303 | |
| 7304 | CreateSession(); |
| 7305 | |
| 7306 | request_.url = GURL("https://mail.example.org/"); |
| 7307 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7308 | HeadersHandler headers_handler; |
| 7309 | trans.SetBeforeHeadersSentCallback( |
| 7310 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7311 | base::Unretained(&headers_handler))); |
| 7312 | RunTransaction(&trans); |
| 7313 | CheckWasHttpResponse(&trans); |
| 7314 | CheckResponsePort(&trans, 70); |
| 7315 | CheckResponseData(&trans, "0123456789"); |
| 7316 | EXPECT_TRUE(headers_handler.was_proxied()); |
| 7317 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 7318 | |
| 7319 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7320 | // proxy socket to disconnect. |
| 7321 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7322 | |
| 7323 | base::RunLoop().RunUntilIdle(); |
| 7324 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7325 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7326 | } |
| 7327 | |
| 7328 | // Performs an HTTP/2 request over QUIC proxy tunnel. |
| 7329 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectSpdyServer) { |
| 7330 | session_params_.enable_quic = true; |
| 7331 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7332 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7333 | |
| 7334 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7335 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7336 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7337 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 7338 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7339 | ConstructClientRequestHeadersPacket( |
| 7340 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7341 | ConnectRequestHeaders("mail.example.org:443"), |
| 7342 | &header_stream_offset)); |
| 7343 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 7344 | 1, GetNthClientInitiatedStreamId(0), false, |
| 7345 | false, GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7346 | |
| 7347 | SpdyTestUtil spdy_util; |
| 7348 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7349 | spdy::SpdySerializedFrame get_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7350 | spdy_util.ConstructSpdyGet("https://mail.example.org/", 1, LOWEST); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7351 | mock_quic_data.AddWrite( |
| 7352 | SYNCHRONOUS, |
| 7353 | ConstructClientAckAndDataPacket( |
| 7354 | 3, false, GetNthClientInitiatedStreamId(0), 1, 1, 1, false, 0, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7355 | quic::QuicStringPiece(get_frame.data(), get_frame.size()))); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7356 | spdy::SpdySerializedFrame resp_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7357 | spdy_util.ConstructSpdyGetReply(nullptr, 0, 1); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7358 | mock_quic_data.AddRead( |
| 7359 | ASYNC, ConstructServerDataPacket( |
| 7360 | 2, GetNthClientInitiatedStreamId(0), false, false, 0, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7361 | quic::QuicStringPiece(resp_frame.data(), resp_frame.size()))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7362 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7363 | spdy::SpdySerializedFrame data_frame = |
Bence Béky | d74f438 | 2018-02-20 18:26:19 | [diff] [blame] | 7364 | spdy_util.ConstructSpdyDataFrame(1, "0123456789", true); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7365 | mock_quic_data.AddRead( |
| 7366 | SYNCHRONOUS, |
| 7367 | ConstructServerDataPacket( |
| 7368 | 3, GetNthClientInitiatedStreamId(0), false, false, resp_frame.size(), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7369 | quic::QuicStringPiece(data_frame.data(), data_frame.size()))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7370 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7371 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7372 | |
| 7373 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7374 | SYNCHRONOUS, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7375 | ConstructClientRstPacket(5, GetNthClientInitiatedStreamId(0), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7376 | quic::QUIC_STREAM_CANCELLED, get_frame.size())); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7377 | |
| 7378 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7379 | |
| 7380 | SSLSocketDataProvider ssl_data(ASYNC, OK); |
| 7381 | ssl_data.next_proto = kProtoHTTP2; |
| 7382 | socket_factory_.AddSSLSocketDataProvider(&ssl_data); |
| 7383 | |
| 7384 | CreateSession(); |
| 7385 | |
| 7386 | request_.url = GURL("https://mail.example.org/"); |
| 7387 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7388 | HeadersHandler headers_handler; |
| 7389 | trans.SetBeforeHeadersSentCallback( |
| 7390 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7391 | base::Unretained(&headers_handler))); |
| 7392 | RunTransaction(&trans); |
| 7393 | CheckWasSpdyResponse(&trans); |
| 7394 | CheckResponsePort(&trans, 70); |
| 7395 | CheckResponseData(&trans, "0123456789"); |
| 7396 | EXPECT_TRUE(headers_handler.was_proxied()); |
| 7397 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 7398 | |
Wez | 0e71711 | 2018-06-18 23:09:22 | [diff] [blame] | 7399 | // Causes MockSSLClientSocket to disconproxyconnecthttpnect, which causes the |
| 7400 | // underlying QUIC proxy socket to disconnect. |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7401 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7402 | |
| 7403 | base::RunLoop().RunUntilIdle(); |
| 7404 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7405 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7406 | } |
| 7407 | |
| 7408 | // Make two HTTP/1.1 requests to the same host over a QUIC proxy tunnel and |
| 7409 | // check that the proxy socket is reused for the second request. |
| 7410 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseTransportSocket) { |
| 7411 | session_params_.enable_quic = true; |
| 7412 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7413 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7414 | |
| 7415 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7416 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7417 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7418 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 7419 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7420 | ConstructClientRequestHeadersPacket( |
| 7421 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7422 | ConnectRequestHeaders("mail.example.org:443"), |
| 7423 | &header_stream_offset)); |
| 7424 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 7425 | 1, GetNthClientInitiatedStreamId(0), false, |
| 7426 | false, GetResponseHeaders("200 OK"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7427 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7428 | quic::QuicStreamOffset client_data_offset = 0; |
| 7429 | quic::QuicStreamOffset server_data_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7430 | const char get_request_1[] = |
| 7431 | "GET / HTTP/1.1\r\n" |
| 7432 | "Host: mail.example.org\r\n" |
| 7433 | "Connection: keep-alive\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7434 | mock_quic_data.AddWrite( |
| 7435 | SYNCHRONOUS, |
| 7436 | ConstructClientAckAndDataPacket( |
| 7437 | 3, false, GetNthClientInitiatedStreamId(0), 1, 1, 1, false, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7438 | client_data_offset, quic::QuicStringPiece(get_request_1))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7439 | client_data_offset += strlen(get_request_1); |
| 7440 | |
| 7441 | const char get_response_1[] = |
| 7442 | "HTTP/1.1 200 OK\r\n" |
| 7443 | "Content-Length: 10\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7444 | mock_quic_data.AddRead( |
| 7445 | ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), |
| 7446 | false, false, server_data_offset, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7447 | quic::QuicStringPiece(get_response_1))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7448 | server_data_offset += strlen(get_response_1); |
| 7449 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7450 | mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerDataPacket( |
| 7451 | 3, GetNthClientInitiatedStreamId(0), |
| 7452 | false, false, server_data_offset, |
| 7453 | quic::QuicStringPiece("0123456789"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7454 | server_data_offset += 10; |
| 7455 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7456 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7457 | |
| 7458 | const char get_request_2[] = |
| 7459 | "GET /2 HTTP/1.1\r\n" |
| 7460 | "Host: mail.example.org\r\n" |
| 7461 | "Connection: keep-alive\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7462 | mock_quic_data.AddWrite( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7463 | SYNCHRONOUS, |
| 7464 | ConstructClientDataPacket(5, GetNthClientInitiatedStreamId(0), false, |
| 7465 | false, client_data_offset, |
| 7466 | quic::QuicStringPiece(get_request_2))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7467 | client_data_offset += strlen(get_request_2); |
| 7468 | |
| 7469 | const char get_response_2[] = |
| 7470 | "HTTP/1.1 200 OK\r\n" |
| 7471 | "Content-Length: 7\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7472 | mock_quic_data.AddRead( |
| 7473 | ASYNC, ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(0), |
| 7474 | false, false, server_data_offset, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7475 | quic::QuicStringPiece(get_response_2))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7476 | server_data_offset += strlen(get_response_2); |
| 7477 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7478 | mock_quic_data.AddRead( |
| 7479 | SYNCHRONOUS, ConstructServerDataPacket( |
| 7480 | 5, GetNthClientInitiatedStreamId(0), false, false, |
| 7481 | server_data_offset, quic::QuicStringPiece("0123456"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7482 | server_data_offset += 7; |
| 7483 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7484 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(6, 5, 4, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7485 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7486 | |
| 7487 | mock_quic_data.AddWrite( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7488 | SYNCHRONOUS, ConstructClientRstPacket(7, GetNthClientInitiatedStreamId(0), |
| 7489 | quic::QUIC_STREAM_CANCELLED, |
| 7490 | client_data_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7491 | |
| 7492 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7493 | |
| 7494 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7495 | |
| 7496 | CreateSession(); |
| 7497 | |
| 7498 | request_.url = GURL("https://mail.example.org/"); |
| 7499 | HttpNetworkTransaction trans_1(DEFAULT_PRIORITY, session_.get()); |
| 7500 | HeadersHandler headers_handler_1; |
| 7501 | trans_1.SetBeforeHeadersSentCallback( |
| 7502 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7503 | base::Unretained(&headers_handler_1))); |
| 7504 | RunTransaction(&trans_1); |
| 7505 | CheckWasHttpResponse(&trans_1); |
| 7506 | CheckResponsePort(&trans_1, 70); |
| 7507 | CheckResponseData(&trans_1, "0123456789"); |
| 7508 | EXPECT_TRUE(headers_handler_1.was_proxied()); |
| 7509 | EXPECT_TRUE(trans_1.GetResponseInfo()->proxy_server.is_quic()); |
| 7510 | |
| 7511 | request_.url = GURL("https://mail.example.org/2"); |
| 7512 | HttpNetworkTransaction trans_2(DEFAULT_PRIORITY, session_.get()); |
| 7513 | HeadersHandler headers_handler_2; |
| 7514 | trans_2.SetBeforeHeadersSentCallback( |
| 7515 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7516 | base::Unretained(&headers_handler_2))); |
| 7517 | RunTransaction(&trans_2); |
| 7518 | CheckWasHttpResponse(&trans_2); |
| 7519 | CheckResponsePort(&trans_2, 70); |
| 7520 | CheckResponseData(&trans_2, "0123456"); |
| 7521 | EXPECT_TRUE(headers_handler_2.was_proxied()); |
| 7522 | EXPECT_TRUE(trans_2.GetResponseInfo()->proxy_server.is_quic()); |
| 7523 | |
| 7524 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7525 | // proxy socket to disconnect. |
| 7526 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7527 | |
| 7528 | base::RunLoop().RunUntilIdle(); |
| 7529 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7530 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7531 | } |
| 7532 | |
| 7533 | // Make an HTTP/1.1 request to one host and an HTTP/2 request to a different |
| 7534 | // host over a QUIC proxy tunnel. Check that the QUIC session to the proxy |
| 7535 | // server is reused for the second request. |
| 7536 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseQuicSession) { |
| 7537 | session_params_.enable_quic = true; |
| 7538 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7539 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7540 | |
| 7541 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7542 | quic::QuicStreamOffset client_header_stream_offset = 0; |
| 7543 | quic::QuicStreamOffset server_header_stream_offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7544 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket( |
| 7545 | 1, &client_header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7546 | |
| 7547 | // CONNECT request and response for first request |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7548 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7549 | ConstructClientRequestHeadersPacket( |
| 7550 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7551 | ConnectRequestHeaders("mail.example.org:443"), |
| 7552 | &client_header_stream_offset)); |
| 7553 | mock_quic_data.AddRead( |
| 7554 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7555 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 7556 | GetResponseHeaders("200 OK"), &server_header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7557 | |
| 7558 | // GET request, response, and data over QUIC tunnel for first request |
| 7559 | const char get_request[] = |
| 7560 | "GET / HTTP/1.1\r\n" |
| 7561 | "Host: mail.example.org\r\n" |
| 7562 | "Connection: keep-alive\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7563 | mock_quic_data.AddWrite( |
| 7564 | SYNCHRONOUS, ConstructClientAckAndDataPacket( |
| 7565 | 3, false, GetNthClientInitiatedStreamId(0), 1, 1, 1, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7566 | false, 0, quic::QuicStringPiece(get_request))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7567 | const char get_response[] = |
| 7568 | "HTTP/1.1 200 OK\r\n" |
| 7569 | "Content-Length: 10\r\n\r\n"; |
| 7570 | mock_quic_data.AddRead( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7571 | ASYNC, |
| 7572 | ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), false, |
| 7573 | false, 0, quic::QuicStringPiece(get_response))); |
| 7574 | mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerDataPacket( |
| 7575 | 3, GetNthClientInitiatedStreamId(0), |
| 7576 | false, false, strlen(get_response), |
| 7577 | quic::QuicStringPiece("0123456789"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7578 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 3, 2, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7579 | |
| 7580 | // CONNECT request and response for second request |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7581 | mock_quic_data.AddWrite( |
| 7582 | SYNCHRONOUS, |
| 7583 | ConstructClientRequestHeadersPacket( |
| 7584 | 5, GetNthClientInitiatedStreamId(1), false, false, |
| 7585 | ConnectRequestHeaders("different.example.org:443"), |
| 7586 | GetNthClientInitiatedStreamId(0), &client_header_stream_offset)); |
| 7587 | mock_quic_data.AddRead( |
| 7588 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7589 | 4, GetNthClientInitiatedStreamId(1), false, false, |
| 7590 | GetResponseHeaders("200 OK"), &server_header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7591 | |
| 7592 | // GET request, response, and data over QUIC tunnel for second request |
| 7593 | SpdyTestUtil spdy_util; |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7594 | spdy::SpdySerializedFrame get_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7595 | spdy_util.ConstructSpdyGet("https://different.example.org/", 1, LOWEST); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7596 | mock_quic_data.AddWrite( |
| 7597 | SYNCHRONOUS, |
| 7598 | ConstructClientAckAndDataPacket( |
| 7599 | 6, false, GetNthClientInitiatedStreamId(1), 4, 4, 1, false, 0, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7600 | quic::QuicStringPiece(get_frame.data(), get_frame.size()))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7601 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7602 | spdy::SpdySerializedFrame resp_frame = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7603 | spdy_util.ConstructSpdyGetReply(nullptr, 0, 1); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7604 | mock_quic_data.AddRead( |
| 7605 | ASYNC, ConstructServerDataPacket( |
| 7606 | 5, GetNthClientInitiatedStreamId(1), false, false, 0, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7607 | quic::QuicStringPiece(resp_frame.data(), resp_frame.size()))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7608 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7609 | spdy::SpdySerializedFrame data_frame = |
Bence Béky | d74f438 | 2018-02-20 18:26:19 | [diff] [blame] | 7610 | spdy_util.ConstructSpdyDataFrame(1, "0123456", true); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7611 | mock_quic_data.AddRead( |
| 7612 | ASYNC, |
| 7613 | ConstructServerDataPacket( |
| 7614 | 6, GetNthClientInitiatedStreamId(1), false, false, resp_frame.size(), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7615 | quic::QuicStringPiece(data_frame.data(), data_frame.size()))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7616 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7617 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(7, 6, 5, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7618 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7619 | |
| 7620 | mock_quic_data.AddWrite( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7621 | SYNCHRONOUS, ConstructClientRstPacket(8, GetNthClientInitiatedStreamId(0), |
| 7622 | quic::QUIC_STREAM_CANCELLED, |
| 7623 | strlen(get_request))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7624 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7625 | SYNCHRONOUS, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7626 | ConstructClientRstPacket(9, GetNthClientInitiatedStreamId(1), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7627 | quic::QUIC_STREAM_CANCELLED, get_frame.size())); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7628 | |
| 7629 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7630 | |
| 7631 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7632 | |
| 7633 | SSLSocketDataProvider ssl_data(ASYNC, OK); |
| 7634 | ssl_data.next_proto = kProtoHTTP2; |
| 7635 | socket_factory_.AddSSLSocketDataProvider(&ssl_data); |
| 7636 | |
| 7637 | CreateSession(); |
| 7638 | |
| 7639 | request_.url = GURL("https://mail.example.org/"); |
| 7640 | HttpNetworkTransaction trans_1(DEFAULT_PRIORITY, session_.get()); |
| 7641 | HeadersHandler headers_handler_1; |
| 7642 | trans_1.SetBeforeHeadersSentCallback( |
| 7643 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7644 | base::Unretained(&headers_handler_1))); |
| 7645 | RunTransaction(&trans_1); |
| 7646 | CheckWasHttpResponse(&trans_1); |
| 7647 | CheckResponsePort(&trans_1, 70); |
| 7648 | CheckResponseData(&trans_1, "0123456789"); |
| 7649 | EXPECT_TRUE(headers_handler_1.was_proxied()); |
| 7650 | EXPECT_TRUE(trans_1.GetResponseInfo()->proxy_server.is_quic()); |
| 7651 | |
| 7652 | request_.url = GURL("https://different.example.org/"); |
| 7653 | HttpNetworkTransaction trans_2(DEFAULT_PRIORITY, session_.get()); |
| 7654 | HeadersHandler headers_handler_2; |
| 7655 | trans_2.SetBeforeHeadersSentCallback( |
| 7656 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7657 | base::Unretained(&headers_handler_2))); |
| 7658 | RunTransaction(&trans_2); |
| 7659 | CheckWasSpdyResponse(&trans_2); |
| 7660 | CheckResponsePort(&trans_2, 70); |
| 7661 | CheckResponseData(&trans_2, "0123456"); |
| 7662 | EXPECT_TRUE(headers_handler_2.was_proxied()); |
| 7663 | EXPECT_TRUE(trans_2.GetResponseInfo()->proxy_server.is_quic()); |
| 7664 | |
| 7665 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7666 | // proxy socket to disconnect. |
| 7667 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7668 | |
| 7669 | base::RunLoop().RunUntilIdle(); |
| 7670 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7671 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7672 | } |
| 7673 | |
| 7674 | // Sends a CONNECT request to a QUIC proxy and receive a 500 response. |
| 7675 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectFailure) { |
| 7676 | session_params_.enable_quic = true; |
| 7677 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7678 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7679 | |
| 7680 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7681 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7682 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7683 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 7684 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7685 | ConstructClientRequestHeadersPacket( |
| 7686 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7687 | ConnectRequestHeaders("mail.example.org:443"), |
| 7688 | &header_stream_offset)); |
| 7689 | mock_quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket( |
| 7690 | 1, GetNthClientInitiatedStreamId(0), false, |
| 7691 | true, GetResponseHeaders("500"))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7692 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7693 | mock_quic_data.AddWrite( |
| 7694 | SYNCHRONOUS, |
| 7695 | ConstructClientAckAndRstPacket(3, GetNthClientInitiatedStreamId(0), |
| 7696 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7697 | |
| 7698 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7699 | |
| 7700 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
| 7701 | |
| 7702 | CreateSession(); |
| 7703 | |
| 7704 | request_.url = GURL("https://mail.example.org/"); |
| 7705 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7706 | HeadersHandler headers_handler; |
| 7707 | trans.SetBeforeHeadersSentCallback( |
| 7708 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7709 | base::Unretained(&headers_handler))); |
| 7710 | TestCompletionCallback callback; |
| 7711 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7712 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7713 | EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback.WaitForResult()); |
| 7714 | EXPECT_EQ(false, headers_handler.was_proxied()); |
| 7715 | |
| 7716 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7717 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7718 | } |
| 7719 | |
| 7720 | // Sends a CONNECT request to a QUIC proxy and get a UDP socket read error. |
| 7721 | TEST_P(QuicNetworkTransactionTest, QuicProxyQuicConnectionError) { |
| 7722 | session_params_.enable_quic = true; |
| 7723 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7724 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7725 | |
| 7726 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7727 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7728 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7729 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 7730 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7731 | ConstructClientRequestHeadersPacket( |
| 7732 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7733 | ConnectRequestHeaders("mail.example.org:443"), |
| 7734 | &header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7735 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_FAILED); |
| 7736 | |
| 7737 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7738 | |
| 7739 | CreateSession(); |
| 7740 | |
| 7741 | request_.url = GURL("https://mail.example.org/"); |
| 7742 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7743 | HeadersHandler headers_handler; |
| 7744 | trans.SetBeforeHeadersSentCallback( |
| 7745 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7746 | base::Unretained(&headers_handler))); |
| 7747 | TestCompletionCallback callback; |
| 7748 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7749 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7750 | EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback.WaitForResult()); |
| 7751 | |
| 7752 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7753 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7754 | } |
| 7755 | |
| 7756 | // Sends an HTTP/1.1 request over QUIC proxy tunnel and gets a bad cert from the |
| 7757 | // host. Retries request and succeeds. |
| 7758 | TEST_P(QuicNetworkTransactionTest, QuicProxyConnectBadCertificate) { |
| 7759 | session_params_.enable_quic = true; |
| 7760 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7761 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7762 | |
| 7763 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7764 | quic::QuicStreamOffset client_header_stream_offset = 0; |
| 7765 | quic::QuicStreamOffset server_header_stream_offset = 0; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7766 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket( |
| 7767 | 1, &client_header_stream_offset)); |
| 7768 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7769 | ConstructClientRequestHeadersPacket( |
| 7770 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7771 | ConnectRequestHeaders("mail.example.org:443"), |
| 7772 | &client_header_stream_offset)); |
| 7773 | mock_quic_data.AddRead( |
| 7774 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7775 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 7776 | GetResponseHeaders("200 OK"), &server_header_stream_offset)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7777 | mock_quic_data.AddWrite( |
| 7778 | SYNCHRONOUS, |
| 7779 | ConstructClientAckAndRstPacket(3, GetNthClientInitiatedStreamId(0), |
| 7780 | quic::QUIC_STREAM_CANCELLED, 1, 1, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7781 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7782 | mock_quic_data.AddWrite( |
| 7783 | SYNCHRONOUS, |
| 7784 | ConstructClientRequestHeadersPacket( |
| 7785 | 4, GetNthClientInitiatedStreamId(1), false, false, |
| 7786 | ConnectRequestHeaders("mail.example.org:443"), |
| 7787 | GetNthClientInitiatedStreamId(0), &client_header_stream_offset)); |
| 7788 | mock_quic_data.AddRead( |
| 7789 | ASYNC, ConstructServerResponseHeadersPacket( |
| 7790 | 2, GetNthClientInitiatedStreamId(1), false, false, |
| 7791 | GetResponseHeaders("200 OK"), &server_header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7792 | |
| 7793 | const char get_request[] = |
| 7794 | "GET / HTTP/1.1\r\n" |
| 7795 | "Host: mail.example.org\r\n" |
| 7796 | "Connection: keep-alive\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7797 | mock_quic_data.AddWrite( |
| 7798 | SYNCHRONOUS, ConstructClientAckAndDataPacket( |
| 7799 | 5, false, GetNthClientInitiatedStreamId(1), 2, 2, 1, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7800 | false, 0, quic::QuicStringPiece(get_request))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7801 | const char get_response[] = |
| 7802 | "HTTP/1.1 200 OK\r\n" |
| 7803 | "Content-Length: 10\r\n\r\n"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7804 | mock_quic_data.AddRead( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7805 | ASYNC, |
| 7806 | ConstructServerDataPacket(3, GetNthClientInitiatedStreamId(1), false, |
| 7807 | false, 0, quic::QuicStringPiece(get_response))); |
| 7808 | |
| 7809 | mock_quic_data.AddRead(SYNCHRONOUS, ConstructServerDataPacket( |
| 7810 | 4, GetNthClientInitiatedStreamId(1), |
| 7811 | false, false, strlen(get_response), |
| 7812 | quic::QuicStringPiece("0123456789"))); |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7813 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(6, 4, 3, 1)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7814 | mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
| 7815 | |
| 7816 | mock_quic_data.AddWrite( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7817 | SYNCHRONOUS, ConstructClientRstPacket(7, GetNthClientInitiatedStreamId(1), |
| 7818 | quic::QUIC_STREAM_CANCELLED, |
| 7819 | strlen(get_request))); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7820 | |
| 7821 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7822 | |
| 7823 | SSLSocketDataProvider ssl_data_bad_cert(ASYNC, ERR_CERT_AUTHORITY_INVALID); |
| 7824 | socket_factory_.AddSSLSocketDataProvider(&ssl_data_bad_cert); |
| 7825 | |
| 7826 | SSLSocketDataProvider ssl_data(ASYNC, OK); |
| 7827 | socket_factory_.AddSSLSocketDataProvider(&ssl_data); |
| 7828 | |
| 7829 | CreateSession(); |
| 7830 | |
| 7831 | request_.url = GURL("https://mail.example.org/"); |
| 7832 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7833 | HeadersHandler headers_handler; |
| 7834 | trans.SetBeforeHeadersSentCallback( |
| 7835 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7836 | base::Unretained(&headers_handler))); |
| 7837 | TestCompletionCallback callback; |
| 7838 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7839 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7840 | EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, callback.WaitForResult()); |
| 7841 | |
| 7842 | rv = trans.RestartIgnoringLastError(callback.callback()); |
| 7843 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7844 | EXPECT_EQ(OK, callback.WaitForResult()); |
| 7845 | |
| 7846 | CheckWasHttpResponse(&trans); |
| 7847 | CheckResponsePort(&trans, 70); |
| 7848 | CheckResponseData(&trans, "0123456789"); |
| 7849 | EXPECT_EQ(true, headers_handler.was_proxied()); |
| 7850 | EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_quic()); |
| 7851 | |
| 7852 | // Causes MockSSLClientSocket to disconnect, which causes the underlying QUIC |
| 7853 | // proxy socket to disconnect. |
| 7854 | NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| 7855 | |
| 7856 | base::RunLoop().RunUntilIdle(); |
| 7857 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7858 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7859 | } |
| 7860 | |
| 7861 | // Checks if a request's specified "user-agent" header shows up correctly in the |
| 7862 | // CONNECT request to a QUIC proxy. |
| 7863 | TEST_P(QuicNetworkTransactionTest, QuicProxyUserAgent) { |
| 7864 | session_params_.enable_quic = true; |
| 7865 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7866 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7867 | |
| 7868 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7869 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7870 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7871 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7872 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7873 | spdy::SpdyHeaderBlock headers = ConnectRequestHeaders("mail.example.org:443"); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7874 | headers["user-agent"] = "Chromium Ultra Awesome X Edition"; |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7875 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7876 | ConstructClientRequestHeadersPacket( |
| 7877 | 2, GetNthClientInitiatedStreamId(0), true, false, |
| 7878 | std::move(headers), &header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7879 | // Return an error, so the transaction stops here (this test isn't interested |
| 7880 | // in the rest). |
| 7881 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_FAILED); |
| 7882 | |
| 7883 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7884 | |
| 7885 | CreateSession(); |
| 7886 | |
| 7887 | request_.url = GURL("https://mail.example.org/"); |
| 7888 | request_.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent, |
| 7889 | "Chromium Ultra Awesome X Edition"); |
| 7890 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 7891 | HeadersHandler headers_handler; |
| 7892 | trans.SetBeforeHeadersSentCallback( |
| 7893 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 7894 | base::Unretained(&headers_handler))); |
| 7895 | TestCompletionCallback callback; |
| 7896 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7897 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7898 | EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback.WaitForResult()); |
| 7899 | |
| 7900 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7901 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7902 | } |
| 7903 | |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7904 | // Makes sure the CONNECT request packet for a QUIC proxy contains the correct |
| 7905 | // HTTP/2 stream dependency and weights given the request priority. |
| 7906 | TEST_P(QuicNetworkTransactionTest, QuicProxyRequestPriority) { |
| 7907 | session_params_.enable_quic = true; |
| 7908 | proxy_resolution_service_ = ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7909 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7910 | |
| 7911 | const RequestPriority request_priority = MEDIUM; |
| 7912 | |
| 7913 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7914 | quic::QuicStreamOffset header_stream_offset = 0; |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7915 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7916 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
| 7917 | mock_quic_data.AddWrite( |
| 7918 | SYNCHRONOUS, |
| 7919 | ConstructClientRequestHeadersPacket( |
| 7920 | 2, GetNthClientInitiatedStreamId(0), true, false, request_priority, |
| 7921 | ConnectRequestHeaders("mail.example.org:443"), 0, |
| 7922 | &header_stream_offset)); |
Yixin Wang | 00fc44c | 2018-01-23 21:12:20 | [diff] [blame] | 7923 | // Return an error, so the transaction stops here (this test isn't interested |
| 7924 | // in the rest). |
| 7925 | mock_quic_data.AddRead(ASYNC, ERR_CONNECTION_FAILED); |
| 7926 | |
| 7927 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 7928 | |
| 7929 | CreateSession(); |
| 7930 | |
| 7931 | request_.url = GURL("https://mail.example.org/"); |
| 7932 | HttpNetworkTransaction trans(request_priority, session_.get()); |
| 7933 | TestCompletionCallback callback; |
| 7934 | int rv = trans.Start(&request_, callback.callback(), net_log_.bound()); |
| 7935 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 7936 | EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback.WaitForResult()); |
| 7937 | |
| 7938 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 7939 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 7940 | } |
| 7941 | |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7942 | // Test the request-challenge-retry sequence for basic auth, over a QUIC |
| 7943 | // connection when setting up a QUIC proxy tunnel. |
| 7944 | TEST_P(QuicNetworkTransactionTest, QuicProxyAuth) { |
| 7945 | const base::string16 kBaz(base::ASCIIToUTF16("baz")); |
| 7946 | const base::string16 kFoo(base::ASCIIToUTF16("foo")); |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7947 | const spdy::SpdyPriority default_priority = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7948 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
| 7949 | |
| 7950 | std::unique_ptr<QuicTestPacketMaker> client_maker; |
| 7951 | std::unique_ptr<QuicTestPacketMaker> server_maker; |
| 7952 | |
| 7953 | // On the second pass, the body read of the auth challenge is synchronous, so |
| 7954 | // IsConnectedAndIdle returns false. The socket should still be drained and |
| 7955 | // reused. See http://crbug.com/544255. |
| 7956 | for (int i = 0; i < 2; ++i) { |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7957 | client_maker.reset( |
| 7958 | new QuicTestPacketMaker(version_, 0, &clock_, kDefaultServerHostName, |
| 7959 | quic::Perspective::IS_CLIENT, |
| 7960 | client_headers_include_h2_stream_dependency_)); |
| 7961 | server_maker.reset( |
| 7962 | new QuicTestPacketMaker(version_, 0, &clock_, kDefaultServerHostName, |
| 7963 | quic::Perspective::IS_SERVER, false)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7964 | |
| 7965 | session_params_.enable_quic = true; |
| 7966 | proxy_resolution_service_ = |
| 7967 | ProxyResolutionService::CreateFixedFromPacResult( |
Ramin Halavati | ca8d525 | 2018-03-12 05:33:49 | [diff] [blame] | 7968 | "QUIC proxy.example.org:70", TRAFFIC_ANNOTATION_FOR_TESTS); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7969 | |
| 7970 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 7971 | quic::QuicStreamOffset client_header_stream_offset = 0; |
| 7972 | quic::QuicStreamOffset server_header_stream_offset = 0; |
| 7973 | quic::QuicStreamOffset client_data_offset = 0; |
| 7974 | quic::QuicStreamOffset server_data_offset = 0; |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7975 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7976 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 7977 | client_maker->MakeInitialSettingsPacket( |
| 7978 | 1, &client_header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7979 | |
| 7980 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7981 | SYNCHRONOUS, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7982 | client_maker->MakeRequestHeadersPacketWithOffsetTracking( |
| 7983 | 2, GetNthClientInitiatedStreamId(0), true, false, default_priority, |
| 7984 | client_maker->ConnectRequestHeaders("mail.example.org:443"), 0, |
| 7985 | &client_header_stream_offset)); |
| 7986 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 7987 | spdy::SpdyHeaderBlock headers = |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7988 | server_maker->GetResponseHeaders("407 Proxy Authentication Required"); |
| 7989 | headers["proxy-authenticate"] = "Basic realm=\"MyRealm1\""; |
| 7990 | headers["content-length"] = "10"; |
| 7991 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7992 | ASYNC, server_maker->MakeResponseHeadersPacketWithOffsetTracking( |
| 7993 | 1, GetNthClientInitiatedStreamId(0), false, false, |
| 7994 | std::move(headers), &server_header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 7995 | |
| 7996 | if (i == 0) { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 7997 | mock_quic_data.AddRead( |
| 7998 | ASYNC, server_maker->MakeDataPacket( |
| 7999 | 2, GetNthClientInitiatedStreamId(0), false, false, |
| 8000 | server_data_offset, "0123456789")); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8001 | } else { |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8002 | mock_quic_data.AddRead( |
| 8003 | SYNCHRONOUS, server_maker->MakeDataPacket( |
| 8004 | 2, GetNthClientInitiatedStreamId(0), false, false, |
| 8005 | server_data_offset, "0123456789")); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8006 | } |
| 8007 | server_data_offset += 10; |
| 8008 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8009 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8010 | client_maker->MakeAckPacket(3, 2, 1, 1, true)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8011 | |
| 8012 | mock_quic_data.AddWrite( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 8013 | SYNCHRONOUS, client_maker->MakeRstPacket( |
| 8014 | 4, false, GetNthClientInitiatedStreamId(0), |
| 8015 | quic::QUIC_STREAM_CANCELLED, client_data_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8016 | |
| 8017 | headers = client_maker->ConnectRequestHeaders("mail.example.org:443"); |
| 8018 | headers["proxy-authorization"] = "Basic Zm9vOmJheg=="; |
| 8019 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8020 | SYNCHRONOUS, |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8021 | client_maker->MakeRequestHeadersPacketWithOffsetTracking( |
| 8022 | 5, GetNthClientInitiatedStreamId(1), false, false, default_priority, |
| 8023 | std::move(headers), GetNthClientInitiatedStreamId(0), |
| 8024 | &client_header_stream_offset)); |
| 8025 | |
| 8026 | // Response to wrong password |
| 8027 | headers = |
| 8028 | server_maker->GetResponseHeaders("407 Proxy Authentication Required"); |
| 8029 | headers["proxy-authenticate"] = "Basic realm=\"MyRealm1\""; |
| 8030 | headers["content-length"] = "10"; |
| 8031 | mock_quic_data.AddRead( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8032 | ASYNC, server_maker->MakeResponseHeadersPacketWithOffsetTracking( |
| 8033 | 3, GetNthClientInitiatedStreamId(1), false, false, |
| 8034 | std::move(headers), &server_header_stream_offset)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8035 | mock_quic_data.AddRead(SYNCHRONOUS, |
| 8036 | ERR_IO_PENDING); // No more data to read |
| 8037 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8038 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8039 | client_maker->MakeAckAndRstPacket( |
| 8040 | 6, false, GetNthClientInitiatedStreamId(1), |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 8041 | quic::QUIC_STREAM_CANCELLED, 3, 3, 1, true)); |
Yixin Wang | 46a273ec30 | 2018-01-23 17:59:56 | [diff] [blame] | 8042 | |
| 8043 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 8044 | mock_quic_data.GetSequencedSocketData()->set_busy_before_sync_reads(true); |
| 8045 | |
| 8046 | CreateSession(); |
| 8047 | |
| 8048 | request_.url = GURL("https://mail.example.org/"); |
| 8049 | // Ensure that proxy authentication is attempted even |
| 8050 | // when the no authentication data flag is set. |
| 8051 | request_.load_flags = LOAD_DO_NOT_SEND_AUTH_DATA; |
| 8052 | { |
| 8053 | HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); |
| 8054 | HeadersHandler headers_handler; |
| 8055 | trans.SetBeforeHeadersSentCallback( |
| 8056 | base::BindRepeating(&HeadersHandler::OnBeforeHeadersSent, |
| 8057 | base::Unretained(&headers_handler))); |
| 8058 | RunTransaction(&trans); |
| 8059 | |
| 8060 | const HttpResponseInfo* response = trans.GetResponseInfo(); |
| 8061 | ASSERT_TRUE(response != nullptr); |
| 8062 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 8063 | EXPECT_EQ("HTTP/1.1 407 Proxy Authentication Required", |
| 8064 | response->headers->GetStatusLine()); |
| 8065 | EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 8066 | EXPECT_EQ(407, response->headers->response_code()); |
| 8067 | EXPECT_EQ(10, response->headers->GetContentLength()); |
| 8068 | EXPECT_EQ(HttpVersion(1, 1), response->headers->GetHttpVersion()); |
| 8069 | const AuthChallengeInfo* auth_challenge = response->auth_challenge.get(); |
| 8070 | ASSERT_TRUE(auth_challenge != nullptr); |
| 8071 | EXPECT_TRUE(auth_challenge->is_proxy); |
| 8072 | EXPECT_EQ("https://proxy.example.org:70", |
| 8073 | auth_challenge->challenger.Serialize()); |
| 8074 | EXPECT_EQ("MyRealm1", auth_challenge->realm); |
| 8075 | EXPECT_EQ("basic", auth_challenge->scheme); |
| 8076 | |
| 8077 | TestCompletionCallback callback; |
| 8078 | int rv = trans.RestartWithAuth(AuthCredentials(kFoo, kBaz), |
| 8079 | callback.callback()); |
| 8080 | EXPECT_EQ(ERR_IO_PENDING, rv); |
| 8081 | EXPECT_EQ(OK, callback.WaitForResult()); |
| 8082 | |
| 8083 | response = trans.GetResponseInfo(); |
| 8084 | ASSERT_TRUE(response != nullptr); |
| 8085 | ASSERT_TRUE(response->headers.get() != nullptr); |
| 8086 | EXPECT_EQ("HTTP/1.1 407 Proxy Authentication Required", |
| 8087 | response->headers->GetStatusLine()); |
| 8088 | EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 8089 | EXPECT_EQ(407, response->headers->response_code()); |
| 8090 | EXPECT_EQ(10, response->headers->GetContentLength()); |
| 8091 | EXPECT_EQ(HttpVersion(1, 1), response->headers->GetHttpVersion()); |
| 8092 | auth_challenge = response->auth_challenge.get(); |
| 8093 | ASSERT_TRUE(auth_challenge != nullptr); |
| 8094 | EXPECT_TRUE(auth_challenge->is_proxy); |
| 8095 | EXPECT_EQ("https://proxy.example.org:70", |
| 8096 | auth_challenge->challenger.Serialize()); |
| 8097 | EXPECT_EQ("MyRealm1", auth_challenge->realm); |
| 8098 | EXPECT_EQ("basic", auth_challenge->scheme); |
| 8099 | } |
| 8100 | // HttpNetworkTransaction is torn down now that it's out of scope, causing |
| 8101 | // the QUIC stream to be cleaned up (since the proxy socket cannot be |
| 8102 | // reused because it's not connected). |
| 8103 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 8104 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 8105 | } |
| 8106 | } |
| 8107 | |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8108 | TEST_P(QuicNetworkTransactionTest, QuicServerPushUpdatesPriority) { |
| 8109 | // Only run this test if HTTP/2 stream dependency info is sent by client (sent |
| 8110 | // in HEADERS frames for requests and PRIORITY frames). |
Zhongyi Shi | 7b4f22b | 2018-08-23 17:22:26 | [diff] [blame] | 8111 | if (version_ < quic::QUIC_VERSION_43 || |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8112 | !client_headers_include_h2_stream_dependency_) { |
| 8113 | return; |
| 8114 | } |
| 8115 | |
| 8116 | session_params_.origins_to_force_quic_on.insert( |
| 8117 | HostPortPair::FromString("mail.example.org:443")); |
| 8118 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 8119 | const quic::QuicStreamId client_stream_0 = GetNthClientInitiatedStreamId(0); |
| 8120 | const quic::QuicStreamId client_stream_1 = GetNthClientInitiatedStreamId(1); |
| 8121 | const quic::QuicStreamId client_stream_2 = GetNthClientInitiatedStreamId(2); |
| 8122 | const quic::QuicStreamId push_stream_0 = GetNthServerInitiatedStreamId(0); |
| 8123 | const quic::QuicStreamId push_stream_1 = GetNthServerInitiatedStreamId(1); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8124 | |
| 8125 | MockQuicData mock_quic_data; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 8126 | quic::QuicStreamOffset header_stream_offset = 0; |
| 8127 | quic::QuicStreamOffset server_header_offset = 0; |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8128 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8129 | SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8130 | |
| 8131 | // Client sends "GET" requests for "/0.png", "/1.png", "/2.png". |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8132 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8133 | ConstructClientRequestHeadersPacket( |
| 8134 | 2, client_stream_0, true, true, HIGHEST, |
| 8135 | GetRequestHeaders("GET", "https", "/0.jpg"), 0, |
| 8136 | &header_stream_offset)); |
| 8137 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8138 | ConstructClientRequestHeadersPacket( |
| 8139 | 3, client_stream_1, true, true, MEDIUM, |
| 8140 | GetRequestHeaders("GET", "https", "/1.jpg"), |
| 8141 | client_stream_0, &header_stream_offset)); |
| 8142 | mock_quic_data.AddWrite(SYNCHRONOUS, |
| 8143 | ConstructClientRequestHeadersPacket( |
| 8144 | 4, client_stream_2, true, true, MEDIUM, |
| 8145 | GetRequestHeaders("GET", "https", "/2.jpg"), |
| 8146 | client_stream_1, &header_stream_offset)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8147 | |
| 8148 | // Server replies "OK" for the three requests. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8149 | mock_quic_data.AddRead( |
| 8150 | ASYNC, ConstructServerResponseHeadersPacket( |
| 8151 | 1, client_stream_0, false, false, GetResponseHeaders("200 OK"), |
| 8152 | &server_header_offset)); |
| 8153 | mock_quic_data.AddRead( |
| 8154 | ASYNC, ConstructServerResponseHeadersPacket( |
| 8155 | 2, client_stream_1, false, false, GetResponseHeaders("200 OK"), |
| 8156 | &server_header_offset)); |
| 8157 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(5, 2, 1, 1)); |
| 8158 | mock_quic_data.AddRead( |
| 8159 | ASYNC, ConstructServerResponseHeadersPacket( |
| 8160 | 3, client_stream_2, false, false, GetResponseHeaders("200 OK"), |
| 8161 | &server_header_offset)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8162 | |
| 8163 | // Server sends two push promises associated with |client_stream_0|; client |
| 8164 | // responds with a PRIORITY frame after each to notify server of HTTP/2 stream |
| 8165 | // dependency info for each push promise stream. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8166 | mock_quic_data.AddRead(ASYNC, |
| 8167 | ConstructServerPushPromisePacket( |
| 8168 | 4, client_stream_0, push_stream_0, false, |
| 8169 | GetRequestHeaders("GET", "https", "/pushed_0.jpg"), |
| 8170 | &server_header_offset, &server_maker_)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8171 | mock_quic_data.AddWrite( |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8172 | SYNCHRONOUS, |
| 8173 | ConstructClientAckAndPriorityFramesPacket( |
| 8174 | 6, false, 4, 3, 1, |
| 8175 | {{push_stream_0, client_stream_2, |
| 8176 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY)}}, |
| 8177 | &header_stream_offset)); |
| 8178 | mock_quic_data.AddRead(ASYNC, |
| 8179 | ConstructServerPushPromisePacket( |
| 8180 | 5, client_stream_0, push_stream_1, false, |
| 8181 | GetRequestHeaders("GET", "https", "/pushed_1.jpg"), |
| 8182 | &server_header_offset, &server_maker_)); |
| 8183 | mock_quic_data.AddWrite( |
| 8184 | SYNCHRONOUS, |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8185 | ConstructClientPriorityPacket(7, false, push_stream_1, push_stream_0, |
| 8186 | DEFAULT_PRIORITY, &header_stream_offset)); |
| 8187 | |
| 8188 | // Server sends the response headers for the two push promises. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8189 | mock_quic_data.AddRead( |
| 8190 | ASYNC, ConstructServerResponseHeadersPacket( |
| 8191 | 6, push_stream_0, false, false, GetResponseHeaders("200 OK"), |
| 8192 | &server_header_offset)); |
| 8193 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(8, 6, 5, 1)); |
| 8194 | mock_quic_data.AddRead( |
| 8195 | ASYNC, ConstructServerResponseHeadersPacket( |
| 8196 | 7, push_stream_1, false, false, GetResponseHeaders("200 OK"), |
| 8197 | &server_header_offset)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8198 | |
| 8199 | // Request for "pushed_0.jpg" matches |push_stream_0|. |push_stream_0|'s |
| 8200 | // priority updates to match the request's priority. Client sends PRIORITY |
| 8201 | // frames to inform server of new HTTP/2 stream dependencies. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8202 | mock_quic_data.AddWrite( |
| 8203 | SYNCHRONOUS, |
| 8204 | ConstructClientAckAndPriorityFramesPacket( |
| 8205 | 9, false, 7, 7, 1, |
| 8206 | {{push_stream_1, client_stream_2, |
| 8207 | ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY)}, |
| 8208 | {push_stream_0, client_stream_0, |
| 8209 | ConvertRequestPriorityToQuicPriority(HIGHEST)}}, |
| 8210 | &header_stream_offset)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8211 | |
| 8212 | // Server sends data for the three requests and the two push promises. |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8213 | mock_quic_data.AddRead( |
| 8214 | ASYNC, ConstructServerDataPacket(8, client_stream_0, false, true, 0, |
| 8215 | "hello 0!")); |
| 8216 | mock_quic_data.AddRead( |
| 8217 | SYNCHRONOUS, ConstructServerDataPacket(9, client_stream_1, false, true, 0, |
| 8218 | "hello 1!")); |
| 8219 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(10, 9, 8, 1)); |
| 8220 | mock_quic_data.AddRead( |
| 8221 | ASYNC, ConstructServerDataPacket(10, client_stream_2, false, true, 0, |
| 8222 | "hello 2!")); |
| 8223 | mock_quic_data.AddRead( |
| 8224 | SYNCHRONOUS, ConstructServerDataPacket(11, push_stream_0, false, true, 0, |
| 8225 | "and hello 0!")); |
| 8226 | mock_quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(11, 11, 10, 1)); |
| 8227 | mock_quic_data.AddRead( |
| 8228 | ASYNC, ConstructServerDataPacket(12, push_stream_1, false, true, 0, |
| 8229 | "and hello 1!")); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8230 | |
Zhongyi Shi | 32f2fd0 | 2018-04-16 18:23:43 | [diff] [blame] | 8231 | mock_quic_data.AddWrite( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 8232 | SYNCHRONOUS, |
| 8233 | ConstructClientAckAndRstPacket( |
| 8234 | 12, push_stream_0, quic::QUIC_RST_ACKNOWLEDGEMENT, 12, 12, 1)); |
Yixin Wang | 385652a | 2018-02-16 02:37:23 | [diff] [blame] | 8235 | |
| 8236 | mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
| 8237 | mock_quic_data.AddRead(ASYNC, 0); // EOF |
| 8238 | mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
| 8239 | |
| 8240 | // The non-alternate protocol job needs to hang in order to guarantee that |
| 8241 | // the alternate-protocol job will "win". |
| 8242 | AddHangingNonAlternateProtocolSocketData(); |
| 8243 | |
| 8244 | CreateSession(); |
| 8245 | |
| 8246 | request_.url = GURL("https://mail.example.org/0.jpg"); |
| 8247 | HttpNetworkTransaction trans_0(HIGHEST, session_.get()); |
| 8248 | TestCompletionCallback callback_0; |
| 8249 | EXPECT_EQ(ERR_IO_PENDING, |
| 8250 | trans_0.Start(&request_, callback_0.callback(), net_log_.bound())); |
| 8251 | base::RunLoop().RunUntilIdle(); |
| 8252 | |
| 8253 | request_.url = GURL("https://mail.example.org/1.jpg"); |
| 8254 | HttpNetworkTransaction trans_1(MEDIUM, session_.get()); |
| 8255 | TestCompletionCallback callback_1; |
| 8256 | EXPECT_EQ(ERR_IO_PENDING, |
| 8257 | trans_1.Start(&request_, callback_1.callback(), net_log_.bound())); |
| 8258 | base::RunLoop().RunUntilIdle(); |
| 8259 | |
| 8260 | request_.url = GURL("https://mail.example.org/2.jpg"); |
| 8261 | HttpNetworkTransaction trans_2(MEDIUM, session_.get()); |
| 8262 | TestCompletionCallback callback_2; |
| 8263 | EXPECT_EQ(ERR_IO_PENDING, |
| 8264 | trans_2.Start(&request_, callback_2.callback(), net_log_.bound())); |
| 8265 | base::RunLoop().RunUntilIdle(); |
| 8266 | |
| 8267 | // Client makes request that matches resource pushed in |pushed_stream_0|. |
| 8268 | request_.url = GURL("https://mail.example.org/pushed_0.jpg"); |
| 8269 | HttpNetworkTransaction trans_3(HIGHEST, session_.get()); |
| 8270 | TestCompletionCallback callback_3; |
| 8271 | EXPECT_EQ(ERR_IO_PENDING, |
| 8272 | trans_3.Start(&request_, callback_3.callback(), net_log_.bound())); |
| 8273 | base::RunLoop().RunUntilIdle(); |
| 8274 | |
| 8275 | EXPECT_TRUE(callback_0.have_result()); |
| 8276 | EXPECT_EQ(OK, callback_0.WaitForResult()); |
| 8277 | EXPECT_TRUE(callback_1.have_result()); |
| 8278 | EXPECT_EQ(OK, callback_1.WaitForResult()); |
| 8279 | EXPECT_TRUE(callback_2.have_result()); |
| 8280 | EXPECT_EQ(OK, callback_2.WaitForResult()); |
| 8281 | |
| 8282 | CheckResponseData(&trans_0, "hello 0!"); // Closes stream 5 |
| 8283 | CheckResponseData(&trans_1, "hello 1!"); // Closes stream 7 |
| 8284 | CheckResponseData(&trans_2, "hello 2!"); // Closes strema 9 |
| 8285 | CheckResponseData(&trans_3, "and hello 0!"); // Closes stream 2, sends RST |
| 8286 | |
| 8287 | mock_quic_data.Resume(); |
| 8288 | base::RunLoop().RunUntilIdle(); |
| 8289 | EXPECT_TRUE(mock_quic_data.AllReadDataConsumed()); |
| 8290 | EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); |
| 8291 | } |
| 8292 | |
[email protected] | 61a52778 | 2013-02-21 03:58:00 | [diff] [blame] | 8293 | } // namespace test |
| 8294 | } // namespace net |