blob: 01c5d88f714555e8a0fcb5f263efbd3a5769f946 [file] [log] [blame]
[email protected]61a527782013-02-21 03:58:001// 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
danakjad1777e2016-04-16 00:56:425#include <memory>
bnc359ed2a2016-04-29 20:43:456#include <ostream>
bnc912a04b2016-04-20 14:19:507#include <string>
8#include <utility>
[email protected]1e960032013-12-20 19:00:209#include <vector>
10
[email protected]61a527782013-02-21 03:58:0011#include "base/compiler_specific.h"
Avi Drissman13fc8932015-12-20 04:40:4612#include "base/macros.h"
mmenke651bae7f2015-12-18 21:26:4513#include "base/run_loop.h"
[email protected]98b20ce2013-05-10 05:55:2614#include "base/stl_util.h"
bnc8be55ebb2015-10-30 14:12:0715#include "base/strings/stringprintf.h"
rtenneti56977812016-01-15 19:26:5616#include "net/base/chunked_upload_data_stream.h"
[email protected]61a527782013-02-21 03:58:0017#include "net/base/test_completion_callback.h"
rsleevid6de8302016-06-21 01:33:2018#include "net/cert/ct_policy_enforcer.h"
[email protected]6e7845ae2013-03-29 21:48:1119#include "net/cert/mock_cert_verifier.h"
rtenneti052774e2015-11-24 21:00:1220#include "net/cert/multi_log_ct_verifier.h"
[email protected]f2cb3cf2013-03-21 01:40:5321#include "net/dns/mock_host_resolver.h"
[email protected]61a527782013-02-21 03:58:0022#include "net/http/http_auth_handler_factory.h"
23#include "net/http/http_network_session.h"
24#include "net/http/http_network_transaction.h"
25#include "net/http/http_server_properties_impl.h"
26#include "net/http/http_stream.h"
27#include "net/http/http_stream_factory.h"
[email protected]c41737d2014-05-14 07:47:1928#include "net/http/http_transaction_test_util.h"
[email protected]b1c988b2013-06-13 06:48:1129#include "net/http/transport_security_state.h"
vishal.b62985ca92015-04-17 08:45:5130#include "net/log/test_net_log.h"
mmenke43758e62015-05-04 21:09:4631#include "net/log/test_net_log_entry.h"
32#include "net/log/test_net_log_util.h"
[email protected]61a527782013-02-21 03:58:0033#include "net/proxy/proxy_config_service_fixed.h"
34#include "net/proxy/proxy_resolver.h"
35#include "net/proxy/proxy_service.h"
bnc508835902015-05-12 20:10:2936#include "net/quic/crypto/proof_verifier_chromium.h"
[email protected]61a527782013-02-21 03:58:0037#include "net/quic/crypto/quic_decrypter.h"
38#include "net/quic/crypto/quic_encrypter.h"
39#include "net/quic/quic_framer.h"
[email protected]24e5bc52013-09-18 15:36:5840#include "net/quic/quic_http_utils.h"
[email protected]ed3fc15d2013-03-08 18:37:4441#include "net/quic/test_tools/crypto_test_utils.h"
[email protected]61a527782013-02-21 03:58:0042#include "net/quic/test_tools/mock_clock.h"
[email protected]e8ff26842013-03-22 21:02:0543#include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
[email protected]61a527782013-02-21 03:58:0044#include "net/quic/test_tools/mock_random.h"
[email protected]1e960032013-12-20 19:00:2045#include "net/quic/test_tools/quic_test_packet_maker.h"
[email protected]61a527782013-02-21 03:58:0046#include "net/quic/test_tools/quic_test_utils.h"
47#include "net/socket/client_socket_factory.h"
48#include "net/socket/mock_client_socket_pool_manager.h"
tbansalca83c002016-04-28 20:56:2849#include "net/socket/socket_performance_watcher.h"
50#include "net/socket/socket_performance_watcher_factory.h"
[email protected]61a527782013-02-21 03:58:0051#include "net/socket/socket_test_util.h"
52#include "net/socket/ssl_client_socket.h"
53#include "net/spdy/spdy_frame_builder.h"
54#include "net/spdy/spdy_framer.h"
[email protected]536fd0b2013-03-14 17:41:5755#include "net/ssl/ssl_config_service_defaults.h"
bnc508835902015-05-12 20:10:2956#include "net/test/cert_test_util.h"
robpercival214763f2016-07-01 23:27:0157#include "net/test/gtest_util.h"
rsleevia69c79a2016-06-22 03:28:4358#include "net/test/test_data_directory.h"
robpercival214763f2016-07-01 23:27:0159#include "testing/gmock/include/gmock/gmock.h"
[email protected]61a527782013-02-21 03:58:0060#include "testing/gtest/include/gtest/gtest.h"
61#include "testing/platform_test.h"
zhongyi3d4a55e72016-04-22 20:36:4662#include "url/gurl.h"
[email protected]61a527782013-02-21 03:58:0063
robpercival214763f2016-07-01 23:27:0164using net::test::IsError;
65using net::test::IsOk;
66
bnc508835902015-05-12 20:10:2967namespace net {
68namespace test {
[email protected]61a527782013-02-21 03:58:0069
70namespace {
71
bnc359ed2a2016-04-29 20:43:4572enum DestinationType {
73 // In pooling tests with two requests for different origins to the same
74 // destination, the destination should be
75 SAME_AS_FIRST, // the same as the first origin,
76 SAME_AS_SECOND, // the same as the second origin, or
77 DIFFERENT, // different from both.
78};
79
rchf114d982015-10-21 01:34:5680static const char kQuicAlternativeServiceHeader[] =
bncc958faa2015-07-31 18:14:5281 "Alt-Svc: quic=\":443\"\r\n\r\n";
rchf47265dc2016-03-21 21:33:1282static const char kQuicAlternativeServiceWithProbabilityHeader[] =
83 "Alt-Svc: quic=\":443\";p=\".5\"\r\n\r\n";
rchf114d982015-10-21 01:34:5684static const char kQuicAlternativeServiceDifferentPortHeader[] =
85 "Alt-Svc: quic=\":137\"\r\n\r\n";
[email protected]1e960032013-12-20 19:00:2086
rch9ae5b3b2016-02-11 00:36:2987const char kDefaultServerHostName[] = "mail.example.org";
bnc359ed2a2016-04-29 20:43:4588const char kDifferentHostname[] = "different.example.com";
89
90// Run QuicNetworkTransactionWithDestinationTest instances with all value
91// combinations of version and destination_type.
92struct PoolingTestParams {
93 friend std::ostream& operator<<(std::ostream& os,
94 const PoolingTestParams& p) {
95 os << "{ version: " << QuicVersionToString(p.version)
96 << ", destination_type: ";
97 switch (p.destination_type) {
98 case SAME_AS_FIRST:
99 os << "SAME_AS_FIRST";
100 break;
101 case SAME_AS_SECOND:
102 os << "SAME_AS_SECOND";
103 break;
104 case DIFFERENT:
105 os << "DIFFERENT";
106 break;
107 }
108 os << " }";
109 return os;
110 }
111
112 QuicVersion version;
113 DestinationType destination_type;
114};
115
116std::vector<PoolingTestParams> GetPoolingTestParams() {
117 std::vector<PoolingTestParams> params;
118 QuicVersionVector all_supported_versions = QuicSupportedVersions();
119 for (const QuicVersion version : all_supported_versions) {
120 params.push_back(PoolingTestParams{version, SAME_AS_FIRST});
121 params.push_back(PoolingTestParams{version, SAME_AS_SECOND});
122 params.push_back(PoolingTestParams{version, DIFFERENT});
123 }
124 return params;
125}
bncb07c05532015-05-14 19:07:20126
[email protected]61a527782013-02-21 03:58:00127} // namespace
128
[email protected]1e960032013-12-20 19:00:20129// Helper class to encapsulate MockReads and MockWrites for QUIC.
130// Simplify ownership issues and the interaction with the MockSocketFactory.
131class MockQuicData {
132 public:
rtennetia004d332015-08-28 06:44:57133 MockQuicData() : packet_number_(0) {}
rcha5399e02015-04-21 19:32:04134
rjshaded5ced072015-12-18 19:26:02135 ~MockQuicData() { STLDeleteElements(&packets_); }
[email protected]1e960032013-12-20 19:00:20136
danakjad1777e2016-04-16 00:56:42137 void AddSynchronousRead(std::unique_ptr<QuicEncryptedPacket> packet) {
[email protected]1e960032013-12-20 19:00:20138 reads_.push_back(MockRead(SYNCHRONOUS, packet->data(), packet->length(),
rtennetia004d332015-08-28 06:44:57139 packet_number_++));
[email protected]1e960032013-12-20 19:00:20140 packets_.push_back(packet.release());
141 }
142
danakjad1777e2016-04-16 00:56:42143 void AddRead(std::unique_ptr<QuicEncryptedPacket> packet) {
rcha5399e02015-04-21 19:32:04144 reads_.push_back(
rtennetia004d332015-08-28 06:44:57145 MockRead(ASYNC, packet->data(), packet->length(), packet_number_++));
rcha5399e02015-04-21 19:32:04146 packets_.push_back(packet.release());
147 }
148
[email protected]1e960032013-12-20 19:00:20149 void AddRead(IoMode mode, int rv) {
rtennetia004d332015-08-28 06:44:57150 reads_.push_back(MockRead(mode, rv, packet_number_++));
[email protected]1e960032013-12-20 19:00:20151 }
152
danakjad1777e2016-04-16 00:56:42153 void AddWrite(std::unique_ptr<QuicEncryptedPacket> packet) {
[email protected]1e960032013-12-20 19:00:20154 writes_.push_back(MockWrite(SYNCHRONOUS, packet->data(), packet->length(),
rtennetia004d332015-08-28 06:44:57155 packet_number_++));
[email protected]1e960032013-12-20 19:00:20156 packets_.push_back(packet.release());
157 }
158
rcha5399e02015-04-21 19:32:04159 void AddSocketDataToFactory(MockClientSocketFactory* factory) {
rjshaded5ced072015-12-18 19:26:02160 MockRead* reads = reads_.empty() ? nullptr : &reads_[0];
161 MockWrite* writes = writes_.empty() ? nullptr : &writes_[0];
rcha5399e02015-04-21 19:32:04162 socket_data_.reset(
163 new SequencedSocketData(reads, reads_.size(), writes, writes_.size()));
[email protected]1e960032013-12-20 19:00:20164 factory->AddSocketDataProvider(socket_data_.get());
165 }
166
mmenkee24011922015-12-17 22:12:59167 void Resume() { socket_data_->Resume(); }
rchb27683c2015-07-29 23:53:50168
[email protected]1e960032013-12-20 19:00:20169 private:
170 std::vector<QuicEncryptedPacket*> packets_;
171 std::vector<MockWrite> writes_;
172 std::vector<MockRead> reads_;
rtennetia004d332015-08-28 06:44:57173 size_t packet_number_;
danakjad1777e2016-04-16 00:56:42174 std::unique_ptr<SequencedSocketData> socket_data_;
[email protected]1e960032013-12-20 19:00:20175};
176
ryansturm49a8cb12016-06-15 16:51:09177class HeadersHandler {
tbansal7cec3812015-02-05 21:25:12178 public:
ryansturm49a8cb12016-06-15 16:51:09179 HeadersHandler() : was_proxied_(false) {}
tbansal7cec3812015-02-05 21:25:12180
ryansturm49a8cb12016-06-15 16:51:09181 bool was_proxied() { return was_proxied_; }
tbansal7cec3812015-02-05 21:25:12182
ryansturm49a8cb12016-06-15 16:51:09183 void OnBeforeHeadersSent(const ProxyInfo& proxy_info,
184 HttpRequestHeaders* request_headers) {
185 if (!proxy_info.is_http() && !proxy_info.is_https() &&
186 !proxy_info.is_quic()) {
187 return;
188 }
189 was_proxied_ = true;
tbansal7cec3812015-02-05 21:25:12190 }
191
192 private:
ryansturm49a8cb12016-06-15 16:51:09193 bool was_proxied_;
tbansal7cec3812015-02-05 21:25:12194};
195
tbansal0f56a39a2016-04-07 22:03:38196class TestSocketPerformanceWatcher : public SocketPerformanceWatcher {
tbansalfdf5665b2015-09-21 22:46:40197 public:
tbansal0f56a39a2016-04-07 22:03:38198 explicit TestSocketPerformanceWatcher(bool* rtt_notification_received)
199 : rtt_notification_received_(rtt_notification_received) {}
200 ~TestSocketPerformanceWatcher() override {}
tbansalfdf5665b2015-09-21 22:46:40201
tbansal0f56a39a2016-04-07 22:03:38202 bool ShouldNotifyUpdatedRTT() const override { return true; }
tbansalfdf5665b2015-09-21 22:46:40203
tbansal0f56a39a2016-04-07 22:03:38204 void OnUpdatedRTTAvailable(const base::TimeDelta& rtt) override {
205 *rtt_notification_received_ = true;
206 }
207
208 void OnConnectionChanged() override {}
209
210 private:
211 bool* rtt_notification_received_;
212
213 DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcher);
214};
215
216class TestSocketPerformanceWatcherFactory
217 : public SocketPerformanceWatcherFactory {
218 public:
219 TestSocketPerformanceWatcherFactory()
220 : watcher_count_(0u), rtt_notification_received_(false) {}
221 ~TestSocketPerformanceWatcherFactory() override {}
222
223 // SocketPerformanceWatcherFactory implementation:
danakjad1777e2016-04-16 00:56:42224 std::unique_ptr<SocketPerformanceWatcher> CreateSocketPerformanceWatcher(
tbansalc8a94ea2015-11-02 23:58:51225 const Protocol protocol) override {
226 if (protocol != PROTOCOL_QUIC) {
tbansal0f56a39a2016-04-07 22:03:38227 return nullptr;
tbansalc8a94ea2015-11-02 23:58:51228 }
229 ++watcher_count_;
danakjad1777e2016-04-16 00:56:42230 return std::unique_ptr<SocketPerformanceWatcher>(
tbansal0f56a39a2016-04-07 22:03:38231 new TestSocketPerformanceWatcher(&rtt_notification_received_));
tbansalfdf5665b2015-09-21 22:46:40232 }
233
tbansalc8a94ea2015-11-02 23:58:51234 size_t watcher_count() const { return watcher_count_; }
tbansalfdf5665b2015-09-21 22:46:40235
tbansalc8a94ea2015-11-02 23:58:51236 bool rtt_notification_received() const { return rtt_notification_received_; }
237
tbansalc8a94ea2015-11-02 23:58:51238 private:
tbansal0f56a39a2016-04-07 22:03:38239 size_t watcher_count_;
tbansalc8a94ea2015-11-02 23:58:51240 bool rtt_notification_received_;
tbansal0f56a39a2016-04-07 22:03:38241
242 DISALLOW_COPY_AND_ASSIGN(TestSocketPerformanceWatcherFactory);
tbansalc8a94ea2015-11-02 23:58:51243};
244
[email protected]1e960032013-12-20 19:00:20245class QuicNetworkTransactionTest
246 : public PlatformTest,
[email protected]5d03bbd2014-03-07 16:19:16247 public ::testing::WithParamInterface<QuicVersion> {
[email protected]61a527782013-02-21 03:58:00248 protected:
[email protected]1c04f9522013-02-21 20:32:43249 QuicNetworkTransactionTest()
rtenneti4b06ae72014-08-26 03:43:43250 : clock_(new MockClock),
alyssar2adf3ac2016-05-03 17:12:58251 client_maker_(GetParam(),
252 0,
253 clock_,
254 kDefaultServerHostName,
255 Perspective::IS_CLIENT),
256 server_maker_(GetParam(),
257 0,
258 clock_,
259 kDefaultServerHostName,
260 Perspective::IS_SERVER),
rtenneti052774e2015-11-24 21:00:12261 cert_transparency_verifier_(new MultiLogCTVerifier()),
[email protected]1c04f9522013-02-21 20:32:43262 ssl_config_service_(new SSLConfigServiceDefaults),
263 proxy_service_(ProxyService::CreateDirect()),
264 auth_handler_factory_(
[email protected]dda75ab2013-06-22 22:43:30265 HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
[email protected]457d6952013-12-13 09:24:58266 random_generator_(0),
rchf114d982015-10-21 01:34:56267 ssl_data_(ASYNC, OK) {
[email protected]aa9b14d2013-05-10 23:45:19268 request_.method = "GET";
rchf114d982015-10-21 01:34:56269 std::string url("https://");
bncb07c05532015-05-14 19:07:20270 url.append(kDefaultServerHostName);
271 request_.url = GURL(url);
[email protected]aa9b14d2013-05-10 23:45:19272 request_.load_flags = 0;
[email protected]98a9d1252014-04-04 00:43:59273 clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
rchf114d982015-10-21 01:34:56274
275 scoped_refptr<X509Certificate> cert(
rch9ae5b3b2016-02-11 00:36:29276 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
rchf114d982015-10-21 01:34:56277 verify_details_.cert_verify_result.verified_cert = cert;
278 verify_details_.cert_verify_result.is_issued_by_known_root = true;
279 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
[email protected]1c04f9522013-02-21 20:32:43280 }
[email protected]61a527782013-02-21 03:58:00281
dcheng67be2b1f2014-10-27 21:47:29282 void SetUp() override {
[email protected]61a527782013-02-21 03:58:00283 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
fdoray92e35a72016-06-10 15:54:55284 base::RunLoop().RunUntilIdle();
[email protected]61a527782013-02-21 03:58:00285 }
286
dcheng67be2b1f2014-10-27 21:47:29287 void TearDown() override {
[email protected]61a527782013-02-21 03:58:00288 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
289 // Empty the current queue.
fdoray92e35a72016-06-10 15:54:55290 base::RunLoop().RunUntilIdle();
[email protected]61a527782013-02-21 03:58:00291 PlatformTest::TearDown();
292 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
fdoray92e35a72016-06-10 15:54:55293 base::RunLoop().RunUntilIdle();
bnc525e175a2016-06-20 12:36:40294 session_.reset();
[email protected]61a527782013-02-21 03:58:00295 }
296
alyssar2adf3ac2016-05-03 17:12:58297 std::unique_ptr<QuicEncryptedPacket> ConstructClientConnectionClosePacket(
rtennetia004d332015-08-28 06:44:57298 QuicPacketNumber num) {
alyssar2adf3ac2016-05-03 17:12:58299 return client_maker_.MakeConnectionClosePacket(num);
[email protected]3316d422013-05-03 21:45:30300 }
301
alyssar2adf3ac2016-05-03 17:12:58302 std::unique_ptr<QuicEncryptedPacket> ConstructServerConnectionClosePacket(
303 QuicPacketNumber num) {
304 return server_maker_.MakeConnectionClosePacket(num);
305 }
306
307 std::unique_ptr<QuicEncryptedPacket> ConstructServerGoAwayPacket(
zhongyi6b5a3892016-03-12 04:46:20308 QuicPacketNumber num,
309 QuicErrorCode error_code,
310 std::string reason_phrase) {
alyssar2adf3ac2016-05-03 17:12:58311 return server_maker_.MakeGoAwayPacket(num, error_code, reason_phrase);
zhongyi6b5a3892016-03-12 04:46:20312 }
313
alyssar2adf3ac2016-05-03 17:12:58314 std::unique_ptr<QuicEncryptedPacket> ConstructClientAckPacket(
rtennetia004d332015-08-28 06:44:57315 QuicPacketNumber largest_received,
316 QuicPacketNumber least_unacked) {
alyssar2adf3ac2016-05-03 17:12:58317 return client_maker_.MakeAckPacket(2, largest_received, least_unacked,
318 least_unacked, true);
zhongyi32569c62016-01-08 02:54:30319 }
320
alyssar2adf3ac2016-05-03 17:12:58321 std::unique_ptr<QuicEncryptedPacket> ConstructClientAckAndRstPacket(
zhongyi6b5a3892016-03-12 04:46:20322 QuicPacketNumber num,
323 QuicStreamId stream_id,
324 QuicRstStreamErrorCode error_code,
325 QuicPacketNumber largest_received,
326 QuicPacketNumber ack_least_unacked,
327 QuicPacketNumber stop_least_unacked) {
alyssar2adf3ac2016-05-03 17:12:58328 return client_maker_.MakeAckAndRstPacket(
329 num, false, stream_id, error_code, largest_received, ack_least_unacked,
330 stop_least_unacked, true);
zhongyi6b5a3892016-03-12 04:46:20331 }
332
alyssar2adf3ac2016-05-03 17:12:58333 std::unique_ptr<QuicEncryptedPacket> ConstructClientAckPacket(
zhongyi32569c62016-01-08 02:54:30334 QuicPacketNumber largest_received,
335 QuicPacketNumber least_unacked,
336 QuicTestPacketMaker* maker) {
alyssar2adf3ac2016-05-03 17:12:58337 return client_maker_.MakeAckPacket(2, largest_received, least_unacked,
338 least_unacked, true);
zhongyi32569c62016-01-08 02:54:30339 }
340
ckrasic769733c2016-06-30 00:42:13341 std::unique_ptr<QuicEncryptedPacket> ConstructClientAckPacket(
342 QuicPacketNumber packet_number,
343 QuicPacketNumber largest_received,
344 QuicPacketNumber ack_least_unacked,
345 QuicPacketNumber stop_least_unacked) {
346 return client_maker_.MakeAckPacket(packet_number, largest_received,
347 ack_least_unacked, stop_least_unacked,
348 true);
349 }
350
alyssar2adf3ac2016-05-03 17:12:58351 std::unique_ptr<QuicEncryptedPacket>
352 ConstructClientAckAndConnectionClosePacket(
zhongyi32569c62016-01-08 02:54:30353 QuicPacketNumber packet_number,
354 QuicPacketNumber largest_received,
355 QuicPacketNumber ack_least_unacked,
356 QuicPacketNumber stop_least_unacked) {
alyssar2adf3ac2016-05-03 17:12:58357 return client_maker_.MakeAckPacket(packet_number, largest_received,
358 ack_least_unacked, stop_least_unacked,
359 true);
[email protected]1e960032013-12-20 19:00:20360 }
[email protected]61a527782013-02-21 03:58:00361
alyssar2adf3ac2016-05-03 17:12:58362 std::unique_ptr<QuicEncryptedPacket>
363 ConstructClientAckAndConnectionClosePacket(
zhongyica364fbb2015-12-12 03:39:12364 QuicPacketNumber num,
365 QuicTime::Delta delta_time_largest_observed,
366 QuicPacketNumber largest_received,
367 QuicPacketNumber least_unacked,
368 QuicErrorCode quic_error,
bnc912a04b2016-04-20 14:19:50369 const std::string& quic_error_details) {
alyssar2adf3ac2016-05-03 17:12:58370 return client_maker_.MakeAckAndConnectionClosePacket(
zhongyica364fbb2015-12-12 03:39:12371 num, false, delta_time_largest_observed, largest_received,
372 least_unacked, quic_error, quic_error_details);
373 }
374
alyssar2adf3ac2016-05-03 17:12:58375 std::unique_ptr<QuicEncryptedPacket> ConstructServerRstPacket(
zhongyica364fbb2015-12-12 03:39:12376 QuicPacketNumber num,
377 bool include_version,
378 QuicStreamId stream_id,
379 QuicRstStreamErrorCode error_code) {
alyssar2adf3ac2016-05-03 17:12:58380 return server_maker_.MakeRstPacket(num, include_version, stream_id,
381 error_code);
zhongyica364fbb2015-12-12 03:39:12382 }
383
zhongyi32569c62016-01-08 02:54:30384 // Uses default QuicTestPacketMaker.
[email protected]1e960032013-12-20 19:00:20385 SpdyHeaderBlock GetRequestHeaders(const std::string& method,
386 const std::string& scheme,
387 const std::string& path) {
alyssar2adf3ac2016-05-03 17:12:58388 return GetRequestHeaders(method, scheme, path, &client_maker_);
zhongyi32569c62016-01-08 02:54:30389 }
390
391 // Uses customized QuicTestPacketMaker.
392 SpdyHeaderBlock GetRequestHeaders(const std::string& method,
393 const std::string& scheme,
394 const std::string& path,
bnc912a04b2016-04-20 14:19:50395 QuicTestPacketMaker* maker) {
396 return maker->GetRequestHeaders(method, scheme, path);
[email protected]61a527782013-02-21 03:58:00397 }
398
[email protected]1e960032013-12-20 19:00:20399 SpdyHeaderBlock GetResponseHeaders(const std::string& status) {
alyssar2adf3ac2016-05-03 17:12:58400 return server_maker_.GetResponseHeaders(status);
[email protected]61a527782013-02-21 03:58:00401 }
402
zhongyi32569c62016-01-08 02:54:30403 // Appends alt_svc headers in the response headers.
404 SpdyHeaderBlock GetResponseHeaders(const std::string& status,
405 const std::string& alt_svc) {
alyssar2adf3ac2016-05-03 17:12:58406 return server_maker_.GetResponseHeaders(status, alt_svc);
zhongyi32569c62016-01-08 02:54:30407 }
408
alyssar2adf3ac2016-05-03 17:12:58409 std::unique_ptr<QuicEncryptedPacket> ConstructServerDataPacket(
rtennetia004d332015-08-28 06:44:57410 QuicPacketNumber packet_number,
[email protected]98b20ce2013-05-10 05:55:26411 QuicStreamId stream_id,
[email protected]e8ff26842013-03-22 21:02:05412 bool should_include_version,
[email protected]61a527782013-02-21 03:58:00413 bool fin,
414 QuicStreamOffset offset,
415 base::StringPiece data) {
alyssar2adf3ac2016-05-03 17:12:58416 return server_maker_.MakeDataPacket(
417 packet_number, stream_id, should_include_version, fin, offset, data);
[email protected]61a527782013-02-21 03:58:00418 }
419
ckrasicda193a82016-07-09 00:39:36420 std::unique_ptr<QuicEncryptedPacket> ConstructClientDataPacket(
421 QuicPacketNumber packet_number,
422 QuicStreamId stream_id,
423 bool should_include_version,
424 bool fin,
425 QuicStreamOffset offset,
426 base::StringPiece data) {
427 return client_maker_.MakeDataPacket(
428 packet_number, stream_id, should_include_version, fin, offset, data);
429 }
430
431 std::unique_ptr<QuicEncryptedPacket> ConstructClientForceHolDataPacket(
432 QuicPacketNumber packet_number,
433 QuicStreamId stream_id,
434 bool should_include_version,
435 bool fin,
436 QuicStreamOffset* offset,
437 base::StringPiece data) {
438 return client_maker_.MakeForceHolDataPacket(
439 packet_number, stream_id, should_include_version, fin, offset, data);
440 }
441
alyssar2adf3ac2016-05-03 17:12:58442 std::unique_ptr<QuicEncryptedPacket> ConstructClientRequestHeadersPacket(
rtennetia004d332015-08-28 06:44:57443 QuicPacketNumber packet_number,
[email protected]1e960032013-12-20 19:00:20444 QuicStreamId stream_id,
445 bool should_include_version,
446 bool fin,
bnc086b39e12016-06-24 13:05:26447 SpdyHeaderBlock headers,
zhongyi32569c62016-01-08 02:54:30448 QuicStreamOffset* offset) {
ianswett0888cff2015-11-24 17:42:16449 SpdyPriority priority =
rtennetif4bdb542015-01-21 14:33:05450 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
alyssar2adf3ac2016-05-03 17:12:58451 return client_maker_.MakeRequestHeadersPacketWithOffsetTracking(
zhongyi32569c62016-01-08 02:54:30452 packet_number, stream_id, should_include_version, fin, priority,
bnc94893a72016-06-30 13:45:25453 std::move(headers), offset);
zhongyi32569c62016-01-08 02:54:30454 }
455
alyssar2adf3ac2016-05-03 17:12:58456 std::unique_ptr<QuicEncryptedPacket> ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:30457 QuicPacketNumber packet_number,
458 QuicStreamId stream_id,
459 bool should_include_version,
460 bool fin,
bnc086b39e12016-06-24 13:05:26461 SpdyHeaderBlock headers,
zhongyi32569c62016-01-08 02:54:30462 QuicStreamOffset* offset,
463 QuicTestPacketMaker* maker) {
464 SpdyPriority priority =
465 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
alyssar2adf3ac2016-05-03 17:12:58466 return client_maker_.MakeRequestHeadersPacketWithOffsetTracking(
zhongyi32569c62016-01-08 02:54:30467 packet_number, stream_id, should_include_version, fin, priority,
bnc94893a72016-06-30 13:45:25468 std::move(headers), offset);
zhongyi32569c62016-01-08 02:54:30469 }
470
alyssar2adf3ac2016-05-03 17:12:58471 std::unique_ptr<QuicEncryptedPacket> ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:30472 QuicPacketNumber packet_number,
473 QuicStreamId stream_id,
474 bool should_include_version,
475 bool fin,
bnc086b39e12016-06-24 13:05:26476 SpdyHeaderBlock headers) {
alyssar2adf3ac2016-05-03 17:12:58477 return ConstructClientRequestHeadersPacket(
bnc086b39e12016-06-24 13:05:26478 packet_number, stream_id, should_include_version, fin,
479 std::move(headers), nullptr, &client_maker_);
zhongyi32569c62016-01-08 02:54:30480 }
alyssar2adf3ac2016-05-03 17:12:58481 std::unique_ptr<QuicEncryptedPacket> ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:30482 QuicPacketNumber packet_number,
483 QuicStreamId stream_id,
484 bool should_include_version,
485 bool fin,
bnc086b39e12016-06-24 13:05:26486 SpdyHeaderBlock headers,
zhongyi32569c62016-01-08 02:54:30487 QuicTestPacketMaker* maker) {
bnc086b39e12016-06-24 13:05:26488 return ConstructClientRequestHeadersPacket(
489 packet_number, stream_id, should_include_version, fin,
490 std::move(headers), nullptr, maker);
[email protected]61a527782013-02-21 03:58:00491 }
492
ckrasic769733c2016-06-30 00:42:13493 std::unique_ptr<QuicEncryptedPacket> ConstructServerPushPromisePacket(
494 QuicPacketNumber packet_number,
495 QuicStreamId stream_id,
496 QuicStreamId promised_stream_id,
497 bool should_include_version,
498 SpdyHeaderBlock headers,
499 QuicStreamOffset* offset,
500 QuicTestPacketMaker* maker) {
501 return maker->MakePushPromisePacket(
502 packet_number, stream_id, promised_stream_id, should_include_version,
503 false, std::move(headers), nullptr, offset);
504 }
505
alyssar2adf3ac2016-05-03 17:12:58506 std::unique_ptr<QuicEncryptedPacket> ConstructServerResponseHeadersPacket(
rtennetia004d332015-08-28 06:44:57507 QuicPacketNumber packet_number,
[email protected]1e960032013-12-20 19:00:20508 QuicStreamId stream_id,
509 bool should_include_version,
510 bool fin,
bnc086b39e12016-06-24 13:05:26511 SpdyHeaderBlock headers) {
alyssar2adf3ac2016-05-03 17:12:58512 return ConstructServerResponseHeadersPacket(
bnc086b39e12016-06-24 13:05:26513 packet_number, stream_id, should_include_version, fin,
514 std::move(headers), nullptr, &server_maker_);
zhongyi32569c62016-01-08 02:54:30515 }
516
alyssar2adf3ac2016-05-03 17:12:58517 std::unique_ptr<QuicEncryptedPacket> ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:30518 QuicPacketNumber packet_number,
519 QuicStreamId stream_id,
520 bool should_include_version,
521 bool fin,
bnc086b39e12016-06-24 13:05:26522 SpdyHeaderBlock headers,
zhongyi32569c62016-01-08 02:54:30523 QuicTestPacketMaker* maker) {
bnc086b39e12016-06-24 13:05:26524 return ConstructServerResponseHeadersPacket(
525 packet_number, stream_id, should_include_version, fin,
526 std::move(headers), nullptr, maker);
zhongyi32569c62016-01-08 02:54:30527 }
528
alyssar2adf3ac2016-05-03 17:12:58529 std::unique_ptr<QuicEncryptedPacket> ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:30530 QuicPacketNumber packet_number,
531 QuicStreamId stream_id,
532 bool should_include_version,
533 bool fin,
bnc086b39e12016-06-24 13:05:26534 SpdyHeaderBlock headers,
zhongyi32569c62016-01-08 02:54:30535 QuicStreamOffset* offset) {
alyssar2adf3ac2016-05-03 17:12:58536 return server_maker_.MakeResponseHeadersPacketWithOffsetTracking(
bnc94893a72016-06-30 13:45:25537 packet_number, stream_id, should_include_version, fin,
538 std::move(headers), offset);
zhongyi32569c62016-01-08 02:54:30539 }
540
alyssar2adf3ac2016-05-03 17:12:58541 std::unique_ptr<QuicEncryptedPacket> ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:30542 QuicPacketNumber packet_number,
543 QuicStreamId stream_id,
544 bool should_include_version,
545 bool fin,
bnc086b39e12016-06-24 13:05:26546 SpdyHeaderBlock headers,
zhongyi32569c62016-01-08 02:54:30547 QuicStreamOffset* offset,
548 QuicTestPacketMaker* maker) {
alyssar2adf3ac2016-05-03 17:12:58549 return server_maker_.MakeResponseHeadersPacketWithOffsetTracking(
bnc94893a72016-06-30 13:45:25550 packet_number, stream_id, should_include_version, fin,
551 std::move(headers), offset);
[email protected]61a527782013-02-21 03:58:00552 }
553
bnc912a04b2016-04-20 14:19:50554 void CreateSession() {
[email protected]4dca587c2013-03-07 16:54:47555 params_.enable_quic = true;
556 params_.quic_clock = clock_;
557 params_.quic_random = &random_generator_;
bnc912a04b2016-04-20 14:19:50558 params_.client_socket_factory = &socket_factory_;
[email protected]e8ff26842013-03-22 21:02:05559 params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
[email protected]1c04f9522013-02-21 20:32:43560 params_.host_resolver = &host_resolver_;
561 params_.cert_verifier = &cert_verifier_;
[email protected]b1c988b2013-06-13 06:48:11562 params_.transport_security_state = &transport_security_state_;
rtenneti052774e2015-11-24 21:00:12563 params_.cert_transparency_verifier = cert_transparency_verifier_.get();
rsleevid6de8302016-06-21 01:33:20564 params_.ct_policy_enforcer = &ct_policy_enforcer_;
tbansalfdf5665b2015-09-21 22:46:40565 params_.socket_performance_watcher_factory =
tbansal0f56a39a2016-04-07 22:03:38566 &test_socket_performance_watcher_factory_;
[email protected]1c04f9522013-02-21 20:32:43567 params_.proxy_service = proxy_service_.get();
568 params_.ssl_config_service = ssl_config_service_.get();
569 params_.http_auth_handler_factory = auth_handler_factory_.get();
bnc525e175a2016-06-20 12:36:40570 params_.http_server_properties = &http_server_properties_;
[email protected]1e960032013-12-20 19:00:20571 params_.quic_supported_versions = SupportedVersions(GetParam());
rch74da0e1a2016-01-14 02:49:32572 for (const char* host :
rch9ae5b3b2016-02-11 00:36:29573 {kDefaultServerHostName, "www.example.org", "news.example.org",
574 "bar.example.org", "foo.example.org", "invalid.example.org",
575 "mail.example.com"}) {
rch74da0e1a2016-01-14 02:49:32576 params_.quic_host_whitelist.insert(host);
577 }
[email protected]61a527782013-02-21 03:58:00578
mmenkee65e7af2015-10-13 17:16:42579 session_.reset(new HttpNetworkSession(params_));
[email protected]11c05872013-08-20 02:04:12580 session_->quic_stream_factory()->set_require_confirmation(false);
rch185ebee2015-07-14 23:56:22581 ASSERT_EQ(params_.quic_socket_receive_buffer_size,
582 session_->quic_stream_factory()->socket_receive_buffer_size());
[email protected]61a527782013-02-21 03:58:00583 }
584
danakjad1777e2016-04-16 00:56:42585 void CheckWasQuicResponse(
586 const std::unique_ptr<HttpNetworkTransaction>& trans) {
[email protected]aa9b14d2013-05-10 23:45:19587 const HttpResponseInfo* response = trans->GetResponseInfo();
rtennetibe635732014-10-02 22:51:42588 ASSERT_TRUE(response != nullptr);
589 ASSERT_TRUE(response->headers.get() != nullptr);
[email protected]aa9b14d2013-05-10 23:45:19590 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
591 EXPECT_TRUE(response->was_fetched_via_spdy);
592 EXPECT_TRUE(response->was_npn_negotiated);
593 EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3,
594 response->connection_info);
595 }
596
danakjad1777e2016-04-16 00:56:42597 void CheckResponsePort(const std::unique_ptr<HttpNetworkTransaction>& trans,
Avi Drissman13fc8932015-12-20 04:40:46598 uint16_t port) {
bnc62a44f022015-04-02 15:59:41599 const HttpResponseInfo* response = trans->GetResponseInfo();
600 ASSERT_TRUE(response != nullptr);
601 EXPECT_EQ(port, response->socket_address.port());
602 }
603
danakjad1777e2016-04-16 00:56:42604 void CheckWasHttpResponse(
605 const std::unique_ptr<HttpNetworkTransaction>& trans) {
[email protected]aa9b14d2013-05-10 23:45:19606 const HttpResponseInfo* response = trans->GetResponseInfo();
rtennetibe635732014-10-02 22:51:42607 ASSERT_TRUE(response != nullptr);
608 ASSERT_TRUE(response->headers.get() != nullptr);
[email protected]aa9b14d2013-05-10 23:45:19609 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
610 EXPECT_FALSE(response->was_fetched_via_spdy);
611 EXPECT_FALSE(response->was_npn_negotiated);
612 EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1,
613 response->connection_info);
614 }
615
danakjad1777e2016-04-16 00:56:42616 void CheckResponseData(const std::unique_ptr<HttpNetworkTransaction>& trans,
[email protected]aa9b14d2013-05-10 23:45:19617 const std::string& expected) {
618 std::string response_data;
robpercival214763f2016-07-01 23:27:01619 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
[email protected]aa9b14d2013-05-10 23:45:19620 EXPECT_EQ(expected, response_data);
621 }
622
danakjad1777e2016-04-16 00:56:42623 void RunTransaction(const std::unique_ptr<HttpNetworkTransaction>& trans) {
[email protected]aa9b14d2013-05-10 23:45:19624 TestCompletionCallback callback;
625 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:01626 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
627 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]aa9b14d2013-05-10 23:45:19628 }
629
630 void SendRequestAndExpectHttpResponse(const std::string& expected) {
danakjad1777e2016-04-16 00:56:42631 std::unique_ptr<HttpNetworkTransaction> trans(
[email protected]90499482013-06-01 00:39:50632 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
bncffc2fdf2015-05-14 18:29:49633 RunTransaction(trans);
[email protected]aa9b14d2013-05-10 23:45:19634 CheckWasHttpResponse(trans);
bncffc2fdf2015-05-14 18:29:49635 CheckResponseData(trans, expected);
[email protected]aa9b14d2013-05-10 23:45:19636 }
637
638 void SendRequestAndExpectQuicResponse(const std::string& expected) {
rchf114d982015-10-21 01:34:56639 SendRequestAndExpectQuicResponseMaybeFromProxy(expected, false, 443);
tbansal7cec3812015-02-05 21:25:12640 }
641
bnc62a44f022015-04-02 15:59:41642 void SendRequestAndExpectQuicResponseFromProxyOnPort(
643 const std::string& expected,
Avi Drissman13fc8932015-12-20 04:40:46644 uint16_t port) {
bnc62a44f022015-04-02 15:59:41645 SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port);
[email protected]aa9b14d2013-05-10 23:45:19646 }
647
648 void AddQuicAlternateProtocolMapping(
649 MockCryptoClientStream::HandshakeMode handshake_mode) {
650 crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
zhongyi3d4a55e72016-04-22 20:36:46651 url::SchemeHostPort server(request_.url);
652 AlternativeService alternative_service(QUIC, server.host(), 443);
bnc7dc7e1b42015-07-28 14:43:12653 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
zhongyi3d4a55e72016-04-22 20:36:46654 http_server_properties_.SetAlternativeService(server, alternative_service,
655 expiration);
[email protected]aa9b14d2013-05-10 23:45:19656 }
657
rchbe69cb902016-02-11 01:10:48658 void AddQuicRemoteAlternativeServiceMapping(
659 MockCryptoClientStream::HandshakeMode handshake_mode,
660 const HostPortPair& alternative) {
661 crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
zhongyi3d4a55e72016-04-22 20:36:46662 url::SchemeHostPort server(request_.url);
rchbe69cb902016-02-11 01:10:48663 AlternativeService alternative_service(QUIC, alternative.host(),
664 alternative.port());
665 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
zhongyi3d4a55e72016-04-22 20:36:46666 http_server_properties_.SetAlternativeService(server, alternative_service,
667 expiration);
rchbe69cb902016-02-11 01:10:48668 }
669
[email protected]aa9b14d2013-05-10 23:45:19670 void ExpectBrokenAlternateProtocolMapping() {
zhongyi3d4a55e72016-04-22 20:36:46671 const url::SchemeHostPort server(request_.url);
bncd9b132e2015-07-08 05:16:10672 const AlternativeServiceVector alternative_service_vector =
zhongyi3d4a55e72016-04-22 20:36:46673 http_server_properties_.GetAlternativeServices(server);
bncd9b132e2015-07-08 05:16:10674 EXPECT_EQ(1u, alternative_service_vector.size());
bnc6be245c12015-05-15 11:24:07675 EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(
bncd9b132e2015-07-08 05:16:10676 alternative_service_vector[0]));
[email protected]aa9b14d2013-05-10 23:45:19677 }
678
[email protected]4d590c9c2014-05-02 05:14:33679 void ExpectQuicAlternateProtocolMapping() {
zhongyi3d4a55e72016-04-22 20:36:46680 const url::SchemeHostPort server(request_.url);
bncd9b132e2015-07-08 05:16:10681 const AlternativeServiceVector alternative_service_vector =
zhongyi3d4a55e72016-04-22 20:36:46682 http_server_properties_.GetAlternativeServices(server);
bncd9b132e2015-07-08 05:16:10683 EXPECT_EQ(1u, alternative_service_vector.size());
684 EXPECT_EQ(QUIC, alternative_service_vector[0].protocol);
[email protected]4d590c9c2014-05-02 05:14:33685 }
686
[email protected]aa9b14d2013-05-10 23:45:19687 void AddHangingNonAlternateProtocolSocketData() {
danakjad1777e2016-04-16 00:56:42688 std::unique_ptr<StaticSocketDataProvider> hanging_data;
zhongyi32569c62016-01-08 02:54:30689 hanging_data.reset(new StaticSocketDataProvider());
[email protected]dda75ab2013-06-22 22:43:30690 MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
zhongyi32569c62016-01-08 02:54:30691 hanging_data->set_connect_data(hanging_connect);
692 hanging_data_.push_back(std::move(hanging_data));
693 socket_factory_.AddSocketDataProvider(hanging_data_.back().get());
rchf114d982015-10-21 01:34:56694 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]aa9b14d2013-05-10 23:45:19695 }
696
rtenneti4b06ae72014-08-26 03:43:43697 MockClock* clock_; // Owned by QuicStreamFactory after CreateSession.
alyssar2adf3ac2016-05-03 17:12:58698 QuicTestPacketMaker client_maker_;
699 QuicTestPacketMaker server_maker_;
danakjad1777e2016-04-16 00:56:42700 std::unique_ptr<HttpNetworkSession> session_;
[email protected]61a527782013-02-21 03:58:00701 MockClientSocketFactory socket_factory_;
rchf114d982015-10-21 01:34:56702 ProofVerifyDetailsChromium verify_details_;
[email protected]e8ff26842013-03-22 21:02:05703 MockCryptoClientStreamFactory crypto_client_stream_factory_;
[email protected]1c04f9522013-02-21 20:32:43704 MockHostResolver host_resolver_;
705 MockCertVerifier cert_verifier_;
[email protected]b1c988b2013-06-13 06:48:11706 TransportSecurityState transport_security_state_;
danakjad1777e2016-04-16 00:56:42707 std::unique_ptr<CTVerifier> cert_transparency_verifier_;
rsleevid6de8302016-06-21 01:33:20708 CTPolicyEnforcer ct_policy_enforcer_;
tbansal0f56a39a2016-04-07 22:03:38709 TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_;
[email protected]1c04f9522013-02-21 20:32:43710 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
danakjad1777e2016-04-16 00:56:42711 std::unique_ptr<ProxyService> proxy_service_;
712 std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
[email protected]61a527782013-02-21 03:58:00713 MockRandom random_generator_;
bnc6be245c12015-05-15 11:24:07714 HttpServerPropertiesImpl http_server_properties_;
[email protected]61a527782013-02-21 03:58:00715 HttpNetworkSession::Params params_;
[email protected]aa9b14d2013-05-10 23:45:19716 HttpRequestInfo request_;
vishal.b62985ca92015-04-17 08:45:51717 BoundTestNetLog net_log_;
danakjad1777e2016-04-16 00:56:42718 std::vector<std::unique_ptr<StaticSocketDataProvider>> hanging_data_;
rchf114d982015-10-21 01:34:56719 SSLSocketDataProvider ssl_data_;
tbansal7cec3812015-02-05 21:25:12720
721 private:
722 void SendRequestAndExpectQuicResponseMaybeFromProxy(
723 const std::string& expected,
bnc62a44f022015-04-02 15:59:41724 bool used_proxy,
Avi Drissman13fc8932015-12-20 04:40:46725 uint16_t port) {
danakjad1777e2016-04-16 00:56:42726 std::unique_ptr<HttpNetworkTransaction> trans(
tbansal7cec3812015-02-05 21:25:12727 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
ryansturm49a8cb12016-06-15 16:51:09728 HeadersHandler headers_handler;
729 trans->SetBeforeHeadersSentCallback(
730 base::Bind(&HeadersHandler::OnBeforeHeadersSent,
731 base::Unretained(&headers_handler)));
bncffc2fdf2015-05-14 18:29:49732 RunTransaction(trans);
tbansal7cec3812015-02-05 21:25:12733 CheckWasQuicResponse(trans);
bnc62a44f022015-04-02 15:59:41734 CheckResponsePort(trans, port);
bncffc2fdf2015-05-14 18:29:49735 CheckResponseData(trans, expected);
ryansturm49a8cb12016-06-15 16:51:09736 EXPECT_EQ(used_proxy, headers_handler.was_proxied());
tbansal7cec3812015-02-05 21:25:12737 }
[email protected]61a527782013-02-21 03:58:00738};
739
rjshaded5ced072015-12-18 19:26:02740INSTANTIATE_TEST_CASE_P(Version,
741 QuicNetworkTransactionTest,
[email protected]1e960032013-12-20 19:00:20742 ::testing::ValuesIn(QuicSupportedVersions()));
743
744TEST_P(QuicNetworkTransactionTest, ForceQuic) {
rtenneti8a2f4632016-03-21 20:26:57745 params_.origins_to_force_quic_on.insert(
746 HostPortPair::FromString("mail.example.org:443"));
[email protected]4dca587c2013-03-07 16:54:47747
[email protected]1e960032013-12-20 19:00:20748 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:58749 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
750 1, kClientDataStreamId1, true, true,
751 GetRequestHeaders("GET", "https", "/")));
752 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
rjshaded5ced072015-12-18 19:26:02753 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:58754 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
755 false, true, 0, "hello!"));
756 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
mmenkee24011922015-12-17 22:12:59757 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read
[email protected]4dca587c2013-03-07 16:54:47758
rcha5399e02015-04-21 19:32:04759 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
[email protected]4dca587c2013-03-07 16:54:47760
[email protected]4dca587c2013-03-07 16:54:47761 CreateSession();
[email protected]4dca587c2013-03-07 16:54:47762
tbansal0f56a39a2016-04-07 22:03:38763 EXPECT_FALSE(
764 test_socket_performance_watcher_factory_.rtt_notification_received());
[email protected]aa9b14d2013-05-10 23:45:19765 SendRequestAndExpectQuicResponse("hello!");
tbansal0f56a39a2016-04-07 22:03:38766 EXPECT_TRUE(
767 test_socket_performance_watcher_factory_.rtt_notification_received());
[email protected]4dca587c2013-03-07 16:54:47768
[email protected]98b20ce2013-05-10 05:55:26769 // Check that the NetLog was filled reasonably.
mmenke43758e62015-05-04 21:09:46770 TestNetLogEntry::List entries;
[email protected]aa9b14d2013-05-10 23:45:19771 net_log_.GetEntries(&entries);
[email protected]98b20ce2013-05-10 05:55:26772 EXPECT_LT(0u, entries.size());
773
774 // Check that we logged a QUIC_SESSION_PACKET_RECEIVED.
ttuttle859dc7a2015-04-23 19:42:29775 int pos = ExpectLogContainsSomewhere(
776 entries, 0, NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
777 NetLog::PHASE_NONE);
[email protected]98b20ce2013-05-10 05:55:26778 EXPECT_LT(0, pos);
779
rchfd527212015-08-25 00:41:26780 // ... and also a TYPE_QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED.
ttuttle859dc7a2015-04-23 19:42:29781 pos = ExpectLogContainsSomewhere(
rchfd527212015-08-25 00:41:26782 entries, 0,
783 NetLog::TYPE_QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED,
ttuttle859dc7a2015-04-23 19:42:29784 NetLog::PHASE_NONE);
[email protected]98b20ce2013-05-10 05:55:26785 EXPECT_LT(0, pos);
786
rtennetia004d332015-08-28 06:44:57787 std::string packet_number;
788 ASSERT_TRUE(entries[pos].GetStringValue("packet_number", &packet_number));
789 EXPECT_EQ("1", packet_number);
[email protected]98b20ce2013-05-10 05:55:26790
rchfd527212015-08-25 00:41:26791 // ... and also a TYPE_QUIC_SESSION_PACKET_AUTHENTICATED.
792 pos = ExpectLogContainsSomewhere(
793 entries, 0, NetLog::TYPE_QUIC_SESSION_PACKET_AUTHENTICATED,
794 NetLog::PHASE_NONE);
795 EXPECT_LT(0, pos);
796
[email protected]98b20ce2013-05-10 05:55:26797 // ... and also a QUIC_SESSION_STREAM_FRAME_RECEIVED.
ttuttle859dc7a2015-04-23 19:42:29798 pos = ExpectLogContainsSomewhere(
799 entries, 0, NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
800 NetLog::PHASE_NONE);
[email protected]98b20ce2013-05-10 05:55:26801 EXPECT_LT(0, pos);
802
803 int log_stream_id;
804 ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id));
[email protected]1e960032013-12-20 19:00:20805 EXPECT_EQ(3, log_stream_id);
[email protected]4dca587c2013-03-07 16:54:47806}
807
rcha2bd44b2016-07-02 00:42:55808TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) {
809 params_.origins_to_force_quic_on.insert(HostPortPair());
810
811 AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
812
813 MockQuicData mock_quic_data;
814 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
815 1, kClientDataStreamId1, true, true,
816 GetRequestHeaders("GET", "https", "/")));
817 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
818 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
819 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
820 false, true, 0, "hello!"));
821 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
822 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read
823
824 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
825
826 CreateSession();
827
828 SendRequestAndExpectQuicResponse("hello!");
829 EXPECT_TRUE(
830 test_socket_performance_watcher_factory_.rtt_notification_received());
831}
832
[email protected]cf3e3cd62014-02-05 16:16:16833TEST_P(QuicNetworkTransactionTest, QuicProxy) {
tbansal9bf26672016-05-11 18:32:45834 params_.enable_quic = true;
rchf114d982015-10-21 01:34:56835 proxy_service_ =
rch9ae5b3b2016-02-11 00:36:29836 ProxyService::CreateFixedFromPacResult("QUIC mail.example.org:70");
[email protected]cf3e3cd62014-02-05 16:16:16837
[email protected]cf3e3cd62014-02-05 16:16:16838 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:58839 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
840 1, kClientDataStreamId1, true, true,
841 GetRequestHeaders("GET", "http", "/")));
842 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
rjshaded5ced072015-12-18 19:26:02843 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:58844 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
845 false, true, 0, "hello!"));
846 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rchb27683c2015-07-29 23:53:50847 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mmenkee24011922015-12-17 22:12:59848 mock_quic_data.AddRead(ASYNC, 0); // EOF
[email protected]cf3e3cd62014-02-05 16:16:16849
rcha5399e02015-04-21 19:32:04850 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
[email protected]cf3e3cd62014-02-05 16:16:16851
tbansal0f56a39a2016-04-07 22:03:38852 EXPECT_FALSE(
853 test_socket_performance_watcher_factory_.rtt_notification_received());
[email protected]cf3e3cd62014-02-05 16:16:16854 // There is no need to set up an alternate protocol job, because
855 // no attempt will be made to speak to the proxy over TCP.
856
rch9ae5b3b2016-02-11 00:36:29857 request_.url = GURL("http://mail.example.org/");
[email protected]cf3e3cd62014-02-05 16:16:16858 CreateSession();
859
bnc62a44f022015-04-02 15:59:41860 SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70);
tbansal0f56a39a2016-04-07 22:03:38861 EXPECT_TRUE(
862 test_socket_performance_watcher_factory_.rtt_notification_received());
[email protected]cf3e3cd62014-02-05 16:16:16863}
864
bnc313ba9c2015-06-11 15:42:31865// Regression test for https://crbug.com/492458. Test that for an HTTP
866// connection through a QUIC proxy, the certificate exhibited by the proxy is
867// checked against the proxy hostname, not the origin hostname.
868TEST_P(QuicNetworkTransactionTest, QuicProxyWithCert) {
rch9ae5b3b2016-02-11 00:36:29869 const std::string origin_host = "mail.example.com";
bnc313ba9c2015-06-11 15:42:31870 const std::string proxy_host = "www.example.org";
871
tbansal9bf26672016-05-11 18:32:45872 params_.enable_quic = true;
rdsmith82957ad2015-09-16 19:42:03873 proxy_service_ =
874 ProxyService::CreateFixedFromPacResult("QUIC " + proxy_host + ":70");
bnc313ba9c2015-06-11 15:42:31875
alyssar2adf3ac2016-05-03 17:12:58876 client_maker_.set_hostname(origin_host);
bnc313ba9c2015-06-11 15:42:31877 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:58878 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
879 1, kClientDataStreamId1, true, true,
880 GetRequestHeaders("GET", "http", "/")));
881 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bnc313ba9c2015-06-11 15:42:31882 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:58883 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
884 false, true, 0, "hello!"));
885 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rchb27683c2015-07-29 23:53:50886 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mmenkee24011922015-12-17 22:12:59887 mock_quic_data.AddRead(ASYNC, 0);
bnc313ba9c2015-06-11 15:42:31888 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
889
890 scoped_refptr<X509Certificate> cert(
rch9ae5b3b2016-02-11 00:36:29891 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
bnc313ba9c2015-06-11 15:42:31892 ASSERT_TRUE(cert.get());
893 // This certificate is valid for the proxy, but not for the origin.
894 bool common_name_fallback_used;
895 EXPECT_TRUE(cert->VerifyNameMatch(proxy_host, &common_name_fallback_used));
896 EXPECT_FALSE(cert->VerifyNameMatch(origin_host, &common_name_fallback_used));
897 ProofVerifyDetailsChromium verify_details;
898 verify_details.cert_verify_result.verified_cert = cert;
899 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
rchf114d982015-10-21 01:34:56900 ProofVerifyDetailsChromium verify_details2;
901 verify_details2.cert_verify_result.verified_cert = cert;
902 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
bnc313ba9c2015-06-11 15:42:31903
904 request_.url = GURL("http://" + origin_host);
rtennetib8e80fb2016-05-16 00:12:09905 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:32906 CreateSession();
bnc313ba9c2015-06-11 15:42:31907 AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
908 SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 70);
909}
910
rchbe69cb902016-02-11 01:10:48911TEST_P(QuicNetworkTransactionTest, AlternativeServicesDifferentHost) {
rchbe69cb902016-02-11 01:10:48912 HostPortPair origin("www.example.org", 443);
913 HostPortPair alternative("mail.example.org", 443);
914
915 base::FilePath certs_dir = GetTestCertsDirectory();
916 scoped_refptr<X509Certificate> cert(
917 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
918 ASSERT_TRUE(cert.get());
919 // TODO(rch): the connection should be "to" the origin, so if the cert is
920 // valid for the origin but not the alternative, that should work too.
921 bool common_name_fallback_used;
922 EXPECT_TRUE(cert->VerifyNameMatch(origin.host(), &common_name_fallback_used));
923 EXPECT_TRUE(
924 cert->VerifyNameMatch(alternative.host(), &common_name_fallback_used));
925 ProofVerifyDetailsChromium verify_details;
926 verify_details.cert_verify_result.verified_cert = cert;
927 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
928
alyssar2adf3ac2016-05-03 17:12:58929 client_maker_.set_hostname(origin.host());
rchbe69cb902016-02-11 01:10:48930 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:58931 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
932 1, kClientDataStreamId1, true, true,
933 GetRequestHeaders("GET", "https", "/")));
934 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
rchbe69cb902016-02-11 01:10:48935 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:58936 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
937 false, true, 0, "hello!"));
938 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rchbe69cb902016-02-11 01:10:48939 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
940 mock_quic_data.AddRead(ASYNC, 0);
941 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
942
943 request_.url = GURL("https://" + origin.host());
944 AddQuicRemoteAlternativeServiceMapping(
945 MockCryptoClientStream::CONFIRM_HANDSHAKE, alternative);
rtennetib8e80fb2016-05-16 00:12:09946 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:32947 CreateSession();
rchbe69cb902016-02-11 01:10:48948
949 SendRequestAndExpectQuicResponse("hello!");
950}
951
[email protected]1e960032013-12-20 19:00:20952TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) {
rtenneti8a2f4632016-03-21 20:26:57953 params_.origins_to_force_quic_on.insert(
954 HostPortPair::FromString("mail.example.org:443"));
[email protected]cebe3282013-05-22 23:49:30955
tbansalfdf5665b2015-09-21 22:46:40956 MockQuicData mock_quic_data1;
957 mock_quic_data1.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
[email protected]1e960032013-12-20 19:00:20958
tbansalfdf5665b2015-09-21 22:46:40959 MockQuicData mock_quic_data2;
zhongyi32569c62016-01-08 02:54:30960 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
tbansalfdf5665b2015-09-21 22:46:40961 mock_quic_data2.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
rch6faa4d42016-01-05 20:48:43962 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
tbansalfdf5665b2015-09-21 22:46:40963
964 mock_quic_data1.AddSocketDataToFactory(&socket_factory_);
965 mock_quic_data2.AddSocketDataToFactory(&socket_factory_);
[email protected]cebe3282013-05-22 23:49:30966
967 CreateSession();
968
tbansal0f56a39a2016-04-07 22:03:38969 EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count());
tbansalfdf5665b2015-09-21 22:46:40970 for (size_t i = 0; i < 2; ++i) {
danakjad1777e2016-04-16 00:56:42971 std::unique_ptr<HttpNetworkTransaction> trans(
tbansalfdf5665b2015-09-21 22:46:40972 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
973 TestCompletionCallback callback;
974 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:01975 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
976 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
tbansal0f56a39a2016-04-07 22:03:38977 EXPECT_EQ(1 + i, test_socket_performance_watcher_factory_.watcher_count());
tbansalfdf5665b2015-09-21 22:46:40978 }
[email protected]cebe3282013-05-22 23:49:30979}
980
tbansalc8a94ea2015-11-02 23:58:51981TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) {
982 // Attempt to "force" quic on 443, which will not be honored.
rtenneti8a2f4632016-03-21 20:26:57983 params_.origins_to_force_quic_on.insert(
984 HostPortPair::FromString("www.google.com:443"));
tbansalc8a94ea2015-11-02 23:58:51985
986 MockRead http_reads[] = {
987 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
988 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
989 MockRead(ASYNC, OK)};
990
991 StaticSocketDataProvider data(http_reads, arraysize(http_reads), nullptr, 0);
992 socket_factory_.AddSocketDataProvider(&data);
993 SSLSocketDataProvider ssl(ASYNC, OK);
994 socket_factory_.AddSSLSocketDataProvider(&ssl);
995
996 CreateSession();
997
998 SendRequestAndExpectHttpResponse("hello world");
tbansal0f56a39a2016-04-07 22:03:38999 EXPECT_EQ(0U, test_socket_performance_watcher_factory_.watcher_count());
tbansalc8a94ea2015-11-02 23:58:511000}
1001
bncc958faa2015-07-31 18:14:521002TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuic) {
bncc958faa2015-07-31 18:14:521003 MockRead http_reads[] = {
rchf114d982015-10-21 01:34:561004 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
1005 MockRead("hello world"),
bncc958faa2015-07-31 18:14:521006 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1007 MockRead(ASYNC, OK)};
1008
1009 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1010 0);
1011 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:561012 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
bncc958faa2015-07-31 18:14:521013
1014 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581015 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1016 1, kClientDataStreamId1, true, true,
1017 GetRequestHeaders("GET", "https", "/")));
1018 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bncc958faa2015-07-31 18:14:521019 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581020 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1021 false, true, 0, "hello!"));
1022 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
bncc958faa2015-07-31 18:14:521023 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mmenkee24011922015-12-17 22:12:591024 mock_quic_data.AddRead(ASYNC, 0); // EOF
bncc958faa2015-07-31 18:14:521025
1026 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1027
rtennetib8e80fb2016-05-16 00:12:091028 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321029 CreateSession();
bncc958faa2015-07-31 18:14:521030
1031 SendRequestAndExpectHttpResponse("hello world");
1032 SendRequestAndExpectQuicResponse("hello!");
1033}
1034
rchf47265dc2016-03-21 21:33:121035TEST_P(QuicNetworkTransactionTest,
1036 UseAlternativeServiceWithProbabilityForQuic) {
1037 MockRead http_reads[] = {
1038 MockRead("HTTP/1.1 200 OK\r\n"),
1039 MockRead(kQuicAlternativeServiceWithProbabilityHeader),
1040 MockRead("hello world"),
1041 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1042 MockRead(ASYNC, OK)};
1043
1044 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1045 0);
1046 socket_factory_.AddSocketDataProvider(&http_data);
1047 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1048
1049 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581050 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1051 1, kClientDataStreamId1, true, true,
1052 GetRequestHeaders("GET", "https", "/")));
1053 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
rchf47265dc2016-03-21 21:33:121054 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581055 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1056 false, true, 0, "hello!"));
1057 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rchf47265dc2016-03-21 21:33:121058 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
1059 mock_quic_data.AddRead(ASYNC, 0); // EOF
1060
1061 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1062
rtennetib8e80fb2016-05-16 00:12:091063 AddHangingNonAlternateProtocolSocketData();
rchf47265dc2016-03-21 21:33:121064 CreateSession();
1065
1066 SendRequestAndExpectHttpResponse("hello world");
1067 SendRequestAndExpectQuicResponse("hello!");
1068}
1069
zhongyi3d4a55e72016-04-22 20:36:461070TEST_P(QuicNetworkTransactionTest, SetAlternativeServiceWithScheme) {
1071 MockRead http_reads[] = {
1072 MockRead("HTTP/1.1 200 OK\r\n"),
1073 MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"),
1074 MockRead("hello world"),
1075 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1076 MockRead(ASYNC, OK)};
1077
1078 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1079 0);
1080
1081 socket_factory_.AddSocketDataProvider(&http_data);
1082 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1083
1084 CreateSession();
bncb26024382016-06-29 02:39:451085 // Send https request, ignore alternative service advertising if response
zhongyi3d4a55e72016-04-22 20:36:461086 // header advertises alternative service for mail.example.org.
bncb26024382016-06-29 02:39:451087 request_.url = GURL("https://mail.example.org:443");
zhongyi3d4a55e72016-04-22 20:36:461088 SendRequestAndExpectHttpResponse("hello world");
bnc525e175a2016-06-20 12:36:401089 HttpServerProperties* http_server_properties =
zhongyi3d4a55e72016-04-22 20:36:461090 session_->http_server_properties();
1091 url::SchemeHostPort http_server("http", "mail.example.org", 443);
1092 url::SchemeHostPort https_server("https", "mail.example.org", 443);
1093 // Check alternative service is set for the correct origin.
zhongyi3d4a55e72016-04-22 20:36:461094 EXPECT_EQ(
bncb26024382016-06-29 02:39:451095 2u, http_server_properties->GetAlternativeServices(https_server).size());
1096 EXPECT_TRUE(
1097 http_server_properties->GetAlternativeServices(http_server).empty());
zhongyi3d4a55e72016-04-22 20:36:461098}
1099
1100TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) {
1101 MockRead http_reads[] = {
1102 MockRead("HTTP/1.1 200 OK\r\n"),
1103 MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"),
1104 MockRead("hello world"),
1105 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1106 MockRead(ASYNC, OK)};
1107
1108 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1109 0);
1110
1111 socket_factory_.AddSocketDataProvider(&http_data);
1112 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1113 socket_factory_.AddSocketDataProvider(&http_data);
1114 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1115
1116 CreateSession();
1117
1118 // Send https request and set alternative services if response header
1119 // advertises alternative service for mail.example.org.
1120 SendRequestAndExpectHttpResponse("hello world");
bnc525e175a2016-06-20 12:36:401121 HttpServerProperties* http_server_properties =
zhongyi3d4a55e72016-04-22 20:36:461122 session_->http_server_properties();
1123
1124 const url::SchemeHostPort https_server(request_.url);
1125 // Check alternative service is set.
1126 AlternativeServiceVector alternative_service_vector =
1127 http_server_properties->GetAlternativeServices(https_server);
1128 EXPECT_EQ(2u, alternative_service_vector.size());
1129
1130 // Send http request to the same origin but with diffrent scheme, should not
1131 // use QUIC.
1132 request_.url = GURL("http://mail.example.org:443");
1133 SendRequestAndExpectHttpResponse("hello world");
1134}
1135
bnc8be55ebb2015-10-30 14:12:071136TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceQuicSupportedVersion) {
1137 std::string altsvc_header = base::StringPrintf(
1138 "Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", GetParam());
1139 MockRead http_reads[] = {
1140 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()),
1141 MockRead("hello world"),
1142 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1143 MockRead(ASYNC, OK)};
1144
1145 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1146 0);
1147 socket_factory_.AddSocketDataProvider(&http_data);
1148 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1149
1150 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581151 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1152 1, kClientDataStreamId1, true, true,
1153 GetRequestHeaders("GET", "https", "/")));
1154 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bnc8be55ebb2015-10-30 14:12:071155 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581156 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1157 false, true, 0, "hello!"));
1158 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
bnc8be55ebb2015-10-30 14:12:071159 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mmenkee24011922015-12-17 22:12:591160 mock_quic_data.AddRead(ASYNC, 0); // EOF
bnc8be55ebb2015-10-30 14:12:071161
1162 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1163
rtennetib8e80fb2016-05-16 00:12:091164 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321165 CreateSession();
bnc8be55ebb2015-10-30 14:12:071166
1167 SendRequestAndExpectHttpResponse("hello world");
1168 SendRequestAndExpectQuicResponse("hello!");
1169}
1170
zhongyi6b5a3892016-03-12 04:46:201171TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) {
1172 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581173 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1174 1, kClientDataStreamId1, true, true,
1175 GetRequestHeaders("GET", "https", "/")));
1176 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
zhongyi6b5a3892016-03-12 04:46:201177 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
1178 // Read a GoAway packet with
1179 // QuicErrorCode: QUIC_ERROR_MIGRATING_PORT from the peer.
alyssar2adf3ac2016-05-03 17:12:581180 mock_quic_data.AddRead(ConstructServerGoAwayPacket(
1181 2, QUIC_ERROR_MIGRATING_PORT,
1182 "connection migration with port change only"));
1183 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
1184 mock_quic_data.AddRead(ConstructServerDataPacket(3, kClientDataStreamId1,
1185 false, true, 0, "hello!"));
1186 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket(
zhongyi6b5a3892016-03-12 04:46:201187 3, kClientDataStreamId1, QUIC_STREAM_CANCELLED, 3, 3, 1));
1188 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
1189 mock_quic_data.AddRead(ASYNC, 0); // EOF
1190
1191 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1192
1193 // The non-alternate protocol job needs to hang in order to guarantee that
1194 // the alternate-protocol job will "win".
1195 AddHangingNonAlternateProtocolSocketData();
1196
1197 // In order for a new QUIC session to be established via alternate-protocol
1198 // without racing an HTTP connection, we need the host resolution to happen
1199 // synchronously. Of course, even though QUIC *could* perform a 0-RTT
1200 // connection to the the server, in this test we require confirmation
1201 // before encrypting so the HTTP job will still start.
1202 host_resolver_.set_synchronous_mode(true);
1203 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
1204 "");
1205 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
1206 AddressList address;
1207 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
1208 nullptr, net_log_.bound());
1209
1210 CreateSession();
1211 session_->quic_stream_factory()->set_require_confirmation(true);
1212 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1213
danakjad1777e2016-04-16 00:56:421214 std::unique_ptr<HttpNetworkTransaction> trans(
zhongyi6b5a3892016-03-12 04:46:201215 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1216 TestCompletionCallback callback;
1217 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:011218 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
zhongyi6b5a3892016-03-12 04:46:201219
1220 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
1221 QuicSession::HANDSHAKE_CONFIRMED);
robpercival214763f2016-07-01 23:27:011222 EXPECT_THAT(callback.WaitForResult(), IsOk());
zhongyi6b5a3892016-03-12 04:46:201223
1224 // Check whether this transaction is correctly marked as received a go-away
1225 // because of migrating port.
1226 NetErrorDetails details;
1227 EXPECT_FALSE(details.quic_port_migration_detected);
1228 trans->PopulateNetErrorDetails(&details);
1229 EXPECT_TRUE(details.quic_port_migration_detected);
1230}
1231
bnc8be55ebb2015-10-30 14:12:071232TEST_P(QuicNetworkTransactionTest,
1233 DoNotUseAlternativeServiceQuicUnsupportedVersion) {
1234 std::string altsvc_header = base::StringPrintf(
1235 "Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", GetParam() - 1);
1236 MockRead http_reads[] = {
1237 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()),
1238 MockRead("hello world"),
1239 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1240 MockRead(ASYNC, OK)};
1241
1242 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1243 0);
1244 socket_factory_.AddSocketDataProvider(&http_data);
1245 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1246 socket_factory_.AddSocketDataProvider(&http_data);
1247 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1248
rch3f4b8452016-02-23 16:59:321249 CreateSession();
bnc8be55ebb2015-10-30 14:12:071250
1251 SendRequestAndExpectHttpResponse("hello world");
1252 SendRequestAndExpectHttpResponse("hello world");
1253}
1254
bncc958faa2015-07-31 18:14:521255// When multiple alternative services are advertised,
zhongyi32569c62016-01-08 02:54:301256// HttpStreamFactoryImpl::RequestStreamInternal() should select the alternative
1257// service which uses existing QUIC session if available. If no existing QUIC
1258// session can be used, use the first alternative service from the list.
1259TEST_P(QuicNetworkTransactionTest, UseExistingAlternativeServiceForQuic) {
bncc958faa2015-07-31 18:14:521260 MockRead http_reads[] = {
1261 MockRead("HTTP/1.1 200 OK\r\n"),
rch9ae5b3b2016-02-11 00:36:291262 MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"),
bncc958faa2015-07-31 18:14:521263 MockRead("hello world"),
1264 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1265 MockRead(ASYNC, OK)};
1266
1267 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1268 0);
1269 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:561270 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
bncc958faa2015-07-31 18:14:521271
zhongyi32569c62016-01-08 02:54:301272 QuicStreamOffset request_header_offset = 0;
1273 QuicStreamOffset response_header_offset = 0;
1274 // First QUIC request data.
rch9ae5b3b2016-02-11 00:36:291275 // Open a session to foo.example.org:443 using the first entry of the
zhongyi32569c62016-01-08 02:54:301276 // alternative service list.
bncc958faa2015-07-31 18:14:521277 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581278 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:301279 1, kClientDataStreamId1, true, true,
1280 GetRequestHeaders("GET", "https", "/"), &request_header_offset));
1281
1282 std::string alt_svc_list =
rch9ae5b3b2016-02-11 00:36:291283 "quic=\"mail.example.org:444\", quic=\"foo.example.org:443\", "
1284 "quic=\"bar.example.org:445\"";
alyssar2adf3ac2016-05-03 17:12:581285 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:301286 1, kClientDataStreamId1, false, false,
1287 GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset));
alyssar2adf3ac2016-05-03 17:12:581288 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1289 false, true, 0, "hello!"));
1290 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
zhongyi32569c62016-01-08 02:54:301291
1292 // Second QUIC request data.
1293 // Connection pooling, using existing session, no need to include version
1294 // as version negotiation has been completed.
alyssar2adf3ac2016-05-03 17:12:581295 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:301296 3, kClientDataStreamId2, false, true,
1297 GetRequestHeaders("GET", "https", "/"), &request_header_offset));
alyssar2adf3ac2016-05-03 17:12:581298 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:301299 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
1300 &response_header_offset));
alyssar2adf3ac2016-05-03 17:12:581301 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2,
1302 false, true, 0, "hello!"));
1303 mock_quic_data.AddWrite(
1304 ConstructClientAckAndConnectionClosePacket(4, 4, 3, 1));
bncc958faa2015-07-31 18:14:521305 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mmenkee24011922015-12-17 22:12:591306 mock_quic_data.AddRead(ASYNC, 0); // EOF
bncc958faa2015-07-31 18:14:521307
1308 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1309
rtennetib8e80fb2016-05-16 00:12:091310 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321311 CreateSession();
bncc958faa2015-07-31 18:14:521312
1313 SendRequestAndExpectHttpResponse("hello world");
zhongyi32569c62016-01-08 02:54:301314
bnc359ed2a2016-04-29 20:43:451315 SendRequestAndExpectQuicResponse("hello!");
1316 SendRequestAndExpectQuicResponse("hello!");
zhongyi32569c62016-01-08 02:54:301317}
1318
bnc359ed2a2016-04-29 20:43:451319// Pool to existing session with matching QuicServerId
1320// even if alternative service destination is different.
1321TEST_P(QuicNetworkTransactionTest, PoolByOrigin) {
zhongyi32569c62016-01-08 02:54:301322 MockQuicData mock_quic_data;
bnc359ed2a2016-04-29 20:43:451323 QuicStreamOffset request_header_offset(0);
1324 QuicStreamOffset response_header_offset(0);
1325
1326 // First request.
alyssar2adf3ac2016-05-03 17:12:581327 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:301328 1, kClientDataStreamId1, true, true,
1329 GetRequestHeaders("GET", "https", "/"), &request_header_offset));
alyssar2adf3ac2016-05-03 17:12:581330 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bnc359ed2a2016-04-29 20:43:451331 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
1332 &response_header_offset));
alyssar2adf3ac2016-05-03 17:12:581333 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1334 false, true, 0, "hello!"));
1335 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
zhongyi32569c62016-01-08 02:54:301336
bnc359ed2a2016-04-29 20:43:451337 // Second request.
alyssar2adf3ac2016-05-03 17:12:581338 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:301339 3, kClientDataStreamId2, false, true,
1340 GetRequestHeaders("GET", "https", "/"), &request_header_offset));
alyssar2adf3ac2016-05-03 17:12:581341 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:301342 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
1343 &response_header_offset));
alyssar2adf3ac2016-05-03 17:12:581344 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2,
1345 false, true, 0, "hello!"));
1346 mock_quic_data.AddWrite(
1347 ConstructClientAckAndConnectionClosePacket(4, 4, 3, 1));
zhongyi32569c62016-01-08 02:54:301348 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
1349 mock_quic_data.AddRead(ASYNC, 0); // EOF
1350
1351 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
bnc359ed2a2016-04-29 20:43:451352
1353 AddHangingNonAlternateProtocolSocketData();
1354 AddHangingNonAlternateProtocolSocketData();
zhongyi32569c62016-01-08 02:54:301355
rch3f4b8452016-02-23 16:59:321356 CreateSession();
zhongyi32569c62016-01-08 02:54:301357
bnc359ed2a2016-04-29 20:43:451358 const char destination1[] = "first.example.com";
1359 const char destination2[] = "second.example.com";
1360
1361 // Set up alternative service entry to destination1.
1362 url::SchemeHostPort server(request_.url);
1363 AlternativeService alternative_service(QUIC, destination1, 443);
1364 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
1365 http_server_properties_.SetAlternativeService(server, alternative_service,
1366 expiration);
1367 // First request opens connection to |destination1|
1368 // with QuicServerId.host() == kDefaultServerHostName.
1369 SendRequestAndExpectQuicResponse("hello!");
1370
1371 // Set up alternative service entry to a different destination.
1372 alternative_service = AlternativeService(QUIC, destination2, 443);
1373 http_server_properties_.SetAlternativeService(server, alternative_service,
1374 expiration);
1375 // Second request pools to existing connection with same QuicServerId,
1376 // even though alternative service destination is different.
1377 SendRequestAndExpectQuicResponse("hello!");
1378}
1379
1380// Pool to existing session with matching destination and matching certificate
1381// even if origin is different, and even if the alternative service with
1382// matching destination is not the first one on the list.
1383TEST_P(QuicNetworkTransactionTest, PoolByDestination) {
1384 GURL origin1 = request_.url;
1385 GURL origin2("https://www.example.org/");
1386 ASSERT_NE(origin1.host(), origin2.host());
1387
1388 MockQuicData mock_quic_data;
1389 QuicStreamOffset request_header_offset(0);
1390 QuicStreamOffset response_header_offset(0);
1391
1392 // First request.
alyssar2adf3ac2016-05-03 17:12:581393 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
bnc359ed2a2016-04-29 20:43:451394 1, kClientDataStreamId1, true, true,
1395 GetRequestHeaders("GET", "https", "/"), &request_header_offset));
alyssar2adf3ac2016-05-03 17:12:581396 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bnc359ed2a2016-04-29 20:43:451397 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
1398 &response_header_offset));
alyssar2adf3ac2016-05-03 17:12:581399 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1400 false, true, 0, "hello!"));
1401 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
bnc359ed2a2016-04-29 20:43:451402
1403 // Second request.
alyssar2adf3ac2016-05-03 17:12:581404 QuicTestPacketMaker client_maker2(GetParam(), 0, clock_, origin2.host(),
1405 Perspective::IS_CLIENT);
1406 QuicTestPacketMaker server_maker2(GetParam(), 0, clock_, origin2.host(),
1407 Perspective::IS_SERVER);
1408 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
bnc359ed2a2016-04-29 20:43:451409 3, kClientDataStreamId2, false, true,
alyssar2adf3ac2016-05-03 17:12:581410 GetRequestHeaders("GET", "https", "/", &client_maker2),
1411 &request_header_offset, &client_maker2));
1412 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bnc359ed2a2016-04-29 20:43:451413 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
alyssar2adf3ac2016-05-03 17:12:581414 &response_header_offset, &server_maker2));
1415 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2,
1416 false, true, 0, "hello!"));
1417 mock_quic_data.AddWrite(
1418 ConstructClientAckAndConnectionClosePacket(4, 4, 3, 1));
bnc359ed2a2016-04-29 20:43:451419 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
1420 mock_quic_data.AddRead(ASYNC, 0); // EOF
1421
1422 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1423
1424 AddHangingNonAlternateProtocolSocketData();
1425 AddHangingNonAlternateProtocolSocketData();
1426
1427 CreateSession();
1428
1429 const char destination1[] = "first.example.com";
1430 const char destination2[] = "second.example.com";
1431
1432 // Set up alternative service for |origin1|.
1433 AlternativeService alternative_service1(QUIC, destination1, 443);
1434 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
1435 http_server_properties_.SetAlternativeService(
1436 url::SchemeHostPort(origin1), alternative_service1, expiration);
1437
1438 // Set up multiple alternative service entries for |origin2|,
1439 // the first one with a different destination as for |origin1|,
1440 // the second one with the same. The second one should be used,
1441 // because the request can be pooled to that one.
1442 AlternativeService alternative_service2(QUIC, destination2, 443);
1443 AlternativeServiceInfoVector alternative_services;
1444 alternative_services.push_back(
1445 AlternativeServiceInfo(alternative_service2, expiration));
1446 alternative_services.push_back(
1447 AlternativeServiceInfo(alternative_service1, expiration));
1448 http_server_properties_.SetAlternativeServices(url::SchemeHostPort(origin2),
1449 alternative_services);
bnc359ed2a2016-04-29 20:43:451450 // First request opens connection to |destination1|
1451 // with QuicServerId.host() == origin1.host().
1452 SendRequestAndExpectQuicResponse("hello!");
1453
1454 // Second request pools to existing connection with same destination,
1455 // because certificate matches, even though QuicServerId is different.
1456 request_.url = origin2;
alyssar2adf3ac2016-05-03 17:12:581457
bnc359ed2a2016-04-29 20:43:451458 SendRequestAndExpectQuicResponse("hello!");
zhongyi32569c62016-01-08 02:54:301459}
1460
1461// Multiple origins have listed the same alternative services. When there's a
1462// existing QUIC session opened by a request to other origin,
1463// if the cert is valid, should select this QUIC session to make the request
1464// if this is also the first existing QUIC session.
1465TEST_P(QuicNetworkTransactionTest,
1466 UseSharedExistingAlternativeServiceForQuicWithValidCert) {
rch9ae5b3b2016-02-11 00:36:291467 // Default cert is valid for *.example.org
zhongyi32569c62016-01-08 02:54:301468
rch9ae5b3b2016-02-11 00:36:291469 // HTTP data for request to www.example.org.
zhongyi32569c62016-01-08 02:54:301470 MockRead http_reads[] = {
1471 MockRead("HTTP/1.1 200 OK\r\n"),
1472 MockRead("Alt-Svc: quic=\":443\"\r\n\r\n"),
rch9ae5b3b2016-02-11 00:36:291473 MockRead("hello world from www.example.org"),
zhongyi32569c62016-01-08 02:54:301474 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1475 MockRead(ASYNC, OK)};
1476
1477 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1478 0);
1479 socket_factory_.AddSocketDataProvider(&http_data);
1480 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1481
1482 // HTTP data for request to mail.example.org.
1483 MockRead http_reads2[] = {
1484 MockRead("HTTP/1.1 200 OK\r\n"),
rch9ae5b3b2016-02-11 00:36:291485 MockRead("Alt-Svc: quic=\":444\", quic=\"www.example.org:443\"\r\n\r\n"),
zhongyi32569c62016-01-08 02:54:301486 MockRead("hello world from mail.example.org"),
1487 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1488 MockRead(ASYNC, OK)};
1489
1490 StaticSocketDataProvider http_data2(http_reads2, arraysize(http_reads2),
1491 nullptr, 0);
1492 socket_factory_.AddSocketDataProvider(&http_data2);
1493 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
1494
1495 QuicStreamOffset request_header_offset = 0;
1496 QuicStreamOffset response_header_offset = 0;
1497
alyssar2adf3ac2016-05-03 17:12:581498 QuicTestPacketMaker client_maker(GetParam(), 0, clock_, "mail.example.org",
1499 Perspective::IS_CLIENT);
1500 server_maker_.set_hostname("www.example.org");
1501 client_maker_.set_hostname("www.example.org");
zhongyi32569c62016-01-08 02:54:301502 MockQuicData mock_quic_data;
1503
1504 // First QUIC request data.
alyssar2adf3ac2016-05-03 17:12:581505 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:301506 1, kClientDataStreamId1, true, true,
1507 GetRequestHeaders("GET", "https", "/"), &request_header_offset));
1508
alyssar2adf3ac2016-05-03 17:12:581509 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:301510 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
1511 &response_header_offset));
alyssar2adf3ac2016-05-03 17:12:581512 mock_quic_data.AddRead(ConstructServerDataPacket(
1513 2, kClientDataStreamId1, false, true, 0, "hello from mail QUIC!"));
1514 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
zhongyi32569c62016-01-08 02:54:301515 // Second QUIC request data.
alyssar2adf3ac2016-05-03 17:12:581516 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
zhongyi32569c62016-01-08 02:54:301517 3, kClientDataStreamId2, false, true,
alyssar2adf3ac2016-05-03 17:12:581518 GetRequestHeaders("GET", "https", "/", &client_maker),
1519 &request_header_offset, &client_maker));
1520 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
zhongyi32569c62016-01-08 02:54:301521 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"),
1522 &response_header_offset));
alyssar2adf3ac2016-05-03 17:12:581523 mock_quic_data.AddRead(ConstructServerDataPacket(
1524 4, kClientDataStreamId2, false, true, 0, "hello from mail QUIC!"));
1525 mock_quic_data.AddWrite(
1526 ConstructClientAckAndConnectionClosePacket(4, 4, 3, 1));
zhongyi32569c62016-01-08 02:54:301527 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
1528 mock_quic_data.AddRead(ASYNC, 0); // EOF
1529
1530 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
zhongyi32569c62016-01-08 02:54:301531
rtennetib8e80fb2016-05-16 00:12:091532 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321533 CreateSession();
zhongyi32569c62016-01-08 02:54:301534
1535 // Send two HTTP requests, responses set up alt-svc lists for the origins.
rch9ae5b3b2016-02-11 00:36:291536 request_.url = GURL("https://www.example.org/");
1537 SendRequestAndExpectHttpResponse("hello world from www.example.org");
zhongyi32569c62016-01-08 02:54:301538 request_.url = GURL("https://mail.example.org/");
1539 SendRequestAndExpectHttpResponse("hello world from mail.example.org");
1540
rch9ae5b3b2016-02-11 00:36:291541 // Open a QUIC session to mail.example.org:443 when making request
1542 // to mail.example.org.
1543 request_.url = GURL("https://www.example.org/");
bnc359ed2a2016-04-29 20:43:451544 SendRequestAndExpectQuicResponse("hello from mail QUIC!");
zhongyi32569c62016-01-08 02:54:301545
rch9ae5b3b2016-02-11 00:36:291546 // Uses the existing QUIC session when making request to www.example.org.
zhongyi32569c62016-01-08 02:54:301547 request_.url = GURL("https://mail.example.org/");
bnc359ed2a2016-04-29 20:43:451548 SendRequestAndExpectQuicResponse("hello from mail QUIC!");
bncc958faa2015-07-31 18:14:521549}
1550
1551TEST_P(QuicNetworkTransactionTest, AlternativeServiceDifferentPort) {
bncc958faa2015-07-31 18:14:521552 MockRead http_reads[] = {
1553 MockRead("HTTP/1.1 200 OK\r\n"),
rchf114d982015-10-21 01:34:561554 MockRead(kQuicAlternativeServiceDifferentPortHeader),
bncc958faa2015-07-31 18:14:521555 MockRead("hello world"),
1556 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1557 MockRead(ASYNC, OK)};
1558
1559 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1560 0);
1561 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:561562 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
bncc958faa2015-07-31 18:14:521563
rtennetib8e80fb2016-05-16 00:12:091564 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321565 CreateSession();
bncc958faa2015-07-31 18:14:521566
1567 SendRequestAndExpectHttpResponse("hello world");
bnc359ed2a2016-04-29 20:43:451568
1569 url::SchemeHostPort http_server("https", kDefaultServerHostName, 443);
1570 AlternativeServiceVector alternative_service_vector =
1571 http_server_properties_.GetAlternativeServices(http_server);
1572 ASSERT_EQ(1u, alternative_service_vector.size());
1573 const AlternativeService alternative_service = alternative_service_vector[0];
1574 EXPECT_EQ(QUIC, alternative_service_vector[0].protocol);
1575 EXPECT_EQ(kDefaultServerHostName, alternative_service_vector[0].host);
1576 EXPECT_EQ(137, alternative_service_vector[0].port);
bncc958faa2015-07-31 18:14:521577}
1578
1579TEST_P(QuicNetworkTransactionTest, ConfirmAlternativeService) {
bncc958faa2015-07-31 18:14:521580 MockRead http_reads[] = {
rchf114d982015-10-21 01:34:561581 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
1582 MockRead("hello world"),
bncc958faa2015-07-31 18:14:521583 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1584 MockRead(ASYNC, OK)};
1585
1586 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1587 0);
1588 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:561589 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
bncc958faa2015-07-31 18:14:521590
1591 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581592 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1593 1, kClientDataStreamId1, true, true,
1594 GetRequestHeaders("GET", "https", "/")));
1595 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bncc958faa2015-07-31 18:14:521596 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581597 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1598 false, true, 0, "hello!"));
1599 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
bncc958faa2015-07-31 18:14:521600 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
1601 mock_quic_data.AddRead(ASYNC, 0); // EOF
bncc958faa2015-07-31 18:14:521602
1603 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1604
rtennetib8e80fb2016-05-16 00:12:091605 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321606 CreateSession();
bncc958faa2015-07-31 18:14:521607
1608 AlternativeService alternative_service(QUIC,
1609 HostPortPair::FromURL(request_.url));
1610 http_server_properties_.MarkAlternativeServiceRecentlyBroken(
1611 alternative_service);
1612 EXPECT_TRUE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
1613 alternative_service));
1614
1615 SendRequestAndExpectHttpResponse("hello world");
1616 SendRequestAndExpectQuicResponse("hello!");
1617
mmenkee24011922015-12-17 22:12:591618 mock_quic_data.Resume();
bncc958faa2015-07-31 18:14:521619
1620 EXPECT_FALSE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
1621 alternative_service));
1622}
1623
bncc958faa2015-07-31 18:14:521624TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuicForHttps) {
bncc958faa2015-07-31 18:14:521625 MockRead http_reads[] = {
rchf114d982015-10-21 01:34:561626 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
1627 MockRead("hello world"),
bncc958faa2015-07-31 18:14:521628 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
1629 MockRead(ASYNC, OK)};
1630
1631 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
1632 0);
1633 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:561634 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
bncc958faa2015-07-31 18:14:521635
1636 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581637 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1638 1, kClientDataStreamId1, true, true,
1639 GetRequestHeaders("GET", "https", "/")));
1640 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bncc958faa2015-07-31 18:14:521641 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581642 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1643 false, true, 0, "hello!"));
1644 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
bncc958faa2015-07-31 18:14:521645 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF
1646
1647 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1648
1649 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321650 CreateSession();
bncc958faa2015-07-31 18:14:521651
1652 // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo().
1653 SendRequestAndExpectHttpResponse("hello world");
1654}
1655
bnc1c196c6e2016-05-28 13:51:481656TEST_P(QuicNetworkTransactionTest, HungAlternativeService) {
[email protected]dda75ab2013-06-22 22:43:301657 crypto_client_stream_factory_.set_handshake_mode(
1658 MockCryptoClientStream::COLD_START);
1659
1660 MockWrite http_writes[] = {
rchf114d982015-10-21 01:34:561661 MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
rch9ae5b3b2016-02-11 00:36:291662 MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"),
rchf114d982015-10-21 01:34:561663 MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")};
[email protected]dda75ab2013-06-22 22:43:301664
1665 MockRead http_reads[] = {
rchf114d982015-10-21 01:34:561666 MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
bnc1c196c6e2016-05-28 13:51:481667 MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader),
rchf114d982015-10-21 01:34:561668 MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
[email protected]dda75ab2013-06-22 22:43:301669
mmenke651bae7f2015-12-18 21:26:451670 SequencedSocketData http_data(http_reads, arraysize(http_reads), http_writes,
1671 arraysize(http_writes));
bnc912a04b2016-04-20 14:19:501672 socket_factory_.AddSocketDataProvider(&http_data);
1673 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]dda75ab2013-06-22 22:43:301674
1675 // The QUIC transaction will not be allowed to complete.
mmenke651bae7f2015-12-18 21:26:451676 MockWrite quic_writes[] = {MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 1)};
[email protected]dda75ab2013-06-22 22:43:301677 MockRead quic_reads[] = {
mmenke651bae7f2015-12-18 21:26:451678 MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0),
[email protected]dda75ab2013-06-22 22:43:301679 };
mmenke651bae7f2015-12-18 21:26:451680 SequencedSocketData quic_data(quic_reads, arraysize(quic_reads), quic_writes,
1681 arraysize(quic_writes));
bnc912a04b2016-04-20 14:19:501682 socket_factory_.AddSocketDataProvider(&quic_data);
[email protected]dda75ab2013-06-22 22:43:301683
1684 // The HTTP transaction will complete.
mmenke651bae7f2015-12-18 21:26:451685 SequencedSocketData http_data2(http_reads, arraysize(http_reads), http_writes,
1686 arraysize(http_writes));
bnc912a04b2016-04-20 14:19:501687 socket_factory_.AddSocketDataProvider(&http_data2);
1688 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]dda75ab2013-06-22 22:43:301689
bnc912a04b2016-04-20 14:19:501690 CreateSession();
[email protected]dda75ab2013-06-22 22:43:301691
1692 // Run the first request.
[email protected]dda75ab2013-06-22 22:43:301693 SendRequestAndExpectHttpResponse("hello world");
rch37de576c2015-05-17 20:28:171694 ASSERT_TRUE(http_data.AllReadDataConsumed());
1695 ASSERT_TRUE(http_data.AllWriteDataConsumed());
[email protected]dda75ab2013-06-22 22:43:301696
1697 // Now run the second request in which the QUIC socket hangs,
1698 // and verify the the transaction continues over HTTP.
[email protected]dda75ab2013-06-22 22:43:301699 SendRequestAndExpectHttpResponse("hello world");
mmenke651bae7f2015-12-18 21:26:451700 base::RunLoop().RunUntilIdle();
[email protected]dda75ab2013-06-22 22:43:301701
rch37de576c2015-05-17 20:28:171702 ASSERT_TRUE(http_data2.AllReadDataConsumed());
1703 ASSERT_TRUE(http_data2.AllWriteDataConsumed());
mmenke651bae7f2015-12-18 21:26:451704 ASSERT_TRUE(quic_data.AllReadDataConsumed());
[email protected]dda75ab2013-06-22 22:43:301705}
1706
[email protected]1e960032013-12-20 19:00:201707TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
[email protected]1e960032013-12-20 19:00:201708 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581709 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1710 1, kClientDataStreamId1, true, true,
1711 GetRequestHeaders("GET", "https", "/")));
1712 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
rjshaded5ced072015-12-18 19:26:021713 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581714 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1715 false, true, 0, "hello!"));
1716 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rchb27683c2015-07-29 23:53:501717 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mmenkee24011922015-12-17 22:12:591718 mock_quic_data.AddRead(ASYNC, 0); // EOF
[email protected]8ba81212013-05-03 13:11:481719
rcha5399e02015-04-21 19:32:041720 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
[email protected]8ba81212013-05-03 13:11:481721
rtennetib8e80fb2016-05-16 00:12:091722 // The non-alternate protocol job needs to hang in order to guarantee that
1723 // the alternate-protocol job will "win".
1724 AddHangingNonAlternateProtocolSocketData();
1725
rch3f4b8452016-02-23 16:59:321726 CreateSession();
[email protected]aa9b14d2013-05-10 23:45:191727 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1728 SendRequestAndExpectQuicResponse("hello!");
[email protected]8ba81212013-05-03 13:11:481729}
1730
[email protected]1e960032013-12-20 19:00:201731TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) {
[email protected]1e960032013-12-20 19:00:201732 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581733 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1734 1, kClientDataStreamId1, true, true,
1735 GetRequestHeaders("GET", "https", "/")));
1736 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
rjshaded5ced072015-12-18 19:26:021737 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581738 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1739 false, true, 0, "hello!"));
1740 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rchb27683c2015-07-29 23:53:501741 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mmenkee24011922015-12-17 22:12:591742 mock_quic_data.AddRead(ASYNC, 0); // EOF
rcha5399e02015-04-21 19:32:041743 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
[email protected]3a120a6b2013-06-25 01:08:271744
1745 // In order for a new QUIC session to be established via alternate-protocol
1746 // without racing an HTTP connection, we need the host resolution to happen
1747 // synchronously.
1748 host_resolver_.set_synchronous_mode(true);
rch9ae5b3b2016-02-11 00:36:291749 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
rchf114d982015-10-21 01:34:561750 "");
rch9ae5b3b2016-02-11 00:36:291751 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
[email protected]3a120a6b2013-06-25 01:08:271752 AddressList address;
rjshaded5ced072015-12-18 19:26:021753 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
1754 nullptr, net_log_.bound());
[email protected]3a120a6b2013-06-25 01:08:271755
rtennetib8e80fb2016-05-16 00:12:091756 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:321757 CreateSession();
[email protected]3a120a6b2013-06-25 01:08:271758 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1759 SendRequestAndExpectQuicResponse("hello!");
1760}
1761
[email protected]0fc924b2014-03-31 04:34:151762TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) {
rdsmith82957ad2015-09-16 19:42:031763 proxy_service_ = ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
[email protected]0fc924b2014-03-31 04:34:151764
1765 // Since we are using a proxy, the QUIC job will not succeed.
1766 MockWrite http_writes[] = {
rch9ae5b3b2016-02-11 00:36:291767 MockWrite(SYNCHRONOUS, 0, "GET http://mail.example.org/ HTTP/1.1\r\n"),
1768 MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"),
rchf114d982015-10-21 01:34:561769 MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n")};
[email protected]0fc924b2014-03-31 04:34:151770
1771 MockRead http_reads[] = {
rchf114d982015-10-21 01:34:561772 MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
bnc1c196c6e2016-05-28 13:51:481773 MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader),
rchf114d982015-10-21 01:34:561774 MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
[email protected]0fc924b2014-03-31 04:34:151775
1776 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
1777 http_writes, arraysize(http_writes));
1778 socket_factory_.AddSocketDataProvider(&http_data);
1779
1780 // In order for a new QUIC session to be established via alternate-protocol
1781 // without racing an HTTP connection, we need the host resolution to happen
1782 // synchronously.
1783 host_resolver_.set_synchronous_mode(true);
rch9ae5b3b2016-02-11 00:36:291784 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
rchf114d982015-10-21 01:34:561785 "");
rch9ae5b3b2016-02-11 00:36:291786 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
[email protected]0fc924b2014-03-31 04:34:151787 AddressList address;
rjshaded5ced072015-12-18 19:26:021788 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
1789 nullptr, net_log_.bound());
[email protected]0fc924b2014-03-31 04:34:151790
rch9ae5b3b2016-02-11 00:36:291791 request_.url = GURL("http://mail.example.org/");
rch3f4b8452016-02-23 16:59:321792 CreateSession();
[email protected]0fc924b2014-03-31 04:34:151793 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1794 SendRequestAndExpectHttpResponse("hello world");
1795}
1796
[email protected]1e960032013-12-20 19:00:201797TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
[email protected]1e960032013-12-20 19:00:201798 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581799 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1800 1, kClientDataStreamId1, true, true,
1801 GetRequestHeaders("GET", "https", "/")));
1802 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
rjshaded5ced072015-12-18 19:26:021803 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:581804 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
1805 false, true, 0, "hello!"));
1806 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
mmenkee24011922015-12-17 22:12:591807 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read
rcha5399e02015-04-21 19:32:041808 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
[email protected]11c05872013-08-20 02:04:121809
rtennetib8e80fb2016-05-16 00:12:091810 // The non-alternate protocol job needs to hang in order to guarantee that
1811 // the alternate-protocol job will "win".
1812 AddHangingNonAlternateProtocolSocketData();
1813
[email protected]11c05872013-08-20 02:04:121814 // In order for a new QUIC session to be established via alternate-protocol
1815 // without racing an HTTP connection, we need the host resolution to happen
1816 // synchronously. Of course, even though QUIC *could* perform a 0-RTT
1817 // connection to the the server, in this test we require confirmation
1818 // before encrypting so the HTTP job will still start.
1819 host_resolver_.set_synchronous_mode(true);
rch9ae5b3b2016-02-11 00:36:291820 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
rchf114d982015-10-21 01:34:561821 "");
rch9ae5b3b2016-02-11 00:36:291822 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
[email protected]11c05872013-08-20 02:04:121823 AddressList address;
rjshaded5ced072015-12-18 19:26:021824 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
1825 nullptr, net_log_.bound());
[email protected]11c05872013-08-20 02:04:121826
rch3f4b8452016-02-23 16:59:321827 CreateSession();
[email protected]11c05872013-08-20 02:04:121828 session_->quic_stream_factory()->set_require_confirmation(true);
1829 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1830
danakjad1777e2016-04-16 00:56:421831 std::unique_ptr<HttpNetworkTransaction> trans(
[email protected]11c05872013-08-20 02:04:121832 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1833 TestCompletionCallback callback;
1834 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:011835 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]11c05872013-08-20 02:04:121836
1837 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
1838 QuicSession::HANDSHAKE_CONFIRMED);
robpercival214763f2016-07-01 23:27:011839 EXPECT_THAT(callback.WaitForResult(), IsOk());
rchb27683c2015-07-29 23:53:501840
1841 CheckWasQuicResponse(trans);
1842 CheckResponseData(trans, "hello!");
[email protected]11c05872013-08-20 02:04:121843}
1844
zhongyica364fbb2015-12-12 03:39:121845TEST_P(QuicNetworkTransactionTest,
1846 LogGranularQuicErrorCodeOnQuicProtocolErrorLocal) {
1847 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581848 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1849 1, kClientDataStreamId1, true, true,
1850 GetRequestHeaders("GET", "https", "/")));
zhongyica364fbb2015-12-12 03:39:121851 // Read a close connection packet with
1852 // QuicErrorCode: QUIC_CRYPTO_VERSION_NOT_SUPPORTED from the peer.
alyssar2adf3ac2016-05-03 17:12:581853 mock_quic_data.AddRead(ConstructServerConnectionClosePacket(1));
zhongyica364fbb2015-12-12 03:39:121854 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1855
1856 // The non-alternate protocol job needs to hang in order to guarantee that
1857 // the alternate-protocol job will "win".
1858 AddHangingNonAlternateProtocolSocketData();
1859
1860 // In order for a new QUIC session to be established via alternate-protocol
1861 // without racing an HTTP connection, we need the host resolution to happen
1862 // synchronously. Of course, even though QUIC *could* perform a 0-RTT
1863 // connection to the the server, in this test we require confirmation
1864 // before encrypting so the HTTP job will still start.
1865 host_resolver_.set_synchronous_mode(true);
rch9ae5b3b2016-02-11 00:36:291866 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
zhongyica364fbb2015-12-12 03:39:121867 "");
rch9ae5b3b2016-02-11 00:36:291868 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
zhongyica364fbb2015-12-12 03:39:121869 AddressList address;
1870 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
1871 nullptr, net_log_.bound());
1872
rch3f4b8452016-02-23 16:59:321873 CreateSession();
zhongyica364fbb2015-12-12 03:39:121874 session_->quic_stream_factory()->set_require_confirmation(true);
1875 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1876
danakjad1777e2016-04-16 00:56:421877 std::unique_ptr<HttpNetworkTransaction> trans(
zhongyica364fbb2015-12-12 03:39:121878 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1879 TestCompletionCallback callback;
1880 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:011881 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
zhongyica364fbb2015-12-12 03:39:121882
1883 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
1884 QuicSession::HANDSHAKE_CONFIRMED);
robpercival214763f2016-07-01 23:27:011885 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR));
zhongyica364fbb2015-12-12 03:39:121886
1887 NetErrorDetails details;
1888 EXPECT_EQ(QUIC_NO_ERROR, details.quic_connection_error);
1889
1890 trans->PopulateNetErrorDetails(&details);
1891 // Verify the error code logged is what sent by the peer.
1892 EXPECT_EQ(QUIC_CRYPTO_VERSION_NOT_SUPPORTED, details.quic_connection_error);
1893}
1894
1895TEST_P(QuicNetworkTransactionTest,
1896 LogGranularQuicErrorCodeOnQuicProtocolErrorRemote) {
1897 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:581898 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1899 1, kClientDataStreamId1, true, true,
1900 GetRequestHeaders("GET", "https", "/")));
zhongyif28b4a32016-04-25 21:35:211901 // Peer sending data from an non-existing stream causes this end to raise
1902 // error and close connection.
1903 mock_quic_data.AddRead(
alyssar2adf3ac2016-05-03 17:12:581904 ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR));
zhongyif28b4a32016-04-25 21:35:211905 std::string quic_error_details = "Data for nonexistent stream";
alyssar2adf3ac2016-05-03 17:12:581906 mock_quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket(
zhongyif28b4a32016-04-25 21:35:211907 2, QuicTime::Delta::Infinite(), 0, 1, QUIC_INVALID_STREAM_ID,
zhongyica364fbb2015-12-12 03:39:121908 quic_error_details));
1909 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1910
1911 // The non-alternate protocol job needs to hang in order to guarantee that
1912 // the alternate-protocol job will "win".
1913 AddHangingNonAlternateProtocolSocketData();
1914
1915 // In order for a new QUIC session to be established via alternate-protocol
1916 // without racing an HTTP connection, we need the host resolution to happen
1917 // synchronously. Of course, even though QUIC *could* perform a 0-RTT
1918 // connection to the the server, in this test we require confirmation
1919 // before encrypting so the HTTP job will still start.
1920 host_resolver_.set_synchronous_mode(true);
rch9ae5b3b2016-02-11 00:36:291921 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
zhongyica364fbb2015-12-12 03:39:121922 "");
rch9ae5b3b2016-02-11 00:36:291923 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
zhongyica364fbb2015-12-12 03:39:121924 AddressList address;
1925 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
1926 nullptr, net_log_.bound());
1927
rch3f4b8452016-02-23 16:59:321928 CreateSession();
zhongyica364fbb2015-12-12 03:39:121929 session_->quic_stream_factory()->set_require_confirmation(true);
1930 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1931
danakjad1777e2016-04-16 00:56:421932 std::unique_ptr<HttpNetworkTransaction> trans(
zhongyica364fbb2015-12-12 03:39:121933 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1934 TestCompletionCallback callback;
1935 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:011936 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
zhongyica364fbb2015-12-12 03:39:121937
1938 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
1939 QuicSession::HANDSHAKE_CONFIRMED);
robpercival214763f2016-07-01 23:27:011940 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR));
zhongyica364fbb2015-12-12 03:39:121941 NetErrorDetails details;
1942 EXPECT_EQ(QUIC_NO_ERROR, details.quic_connection_error);
1943
1944 trans->PopulateNetErrorDetails(&details);
zhongyif28b4a32016-04-25 21:35:211945 EXPECT_EQ(QUIC_INVALID_STREAM_ID, details.quic_connection_error);
zhongyica364fbb2015-12-12 03:39:121946}
1947
rchcd5f1c62016-06-23 02:43:481948TEST_P(QuicNetworkTransactionTest, RstSteamErrorHandling) {
1949 MockQuicData mock_quic_data;
1950 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
1951 1, kClientDataStreamId1, true, true,
1952 GetRequestHeaders("GET", "https", "/")));
1953 // Read the response headers, then a RST_STREAM frame.
1954 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
1955 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
1956 mock_quic_data.AddRead(ConstructServerRstPacket(
1957 2, false, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
1958 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
1959 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
1960 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
1961
1962 // The non-alternate protocol job needs to hang in order to guarantee that
1963 // the alternate-protocol job will "win".
1964 AddHangingNonAlternateProtocolSocketData();
1965
1966 // In order for a new QUIC session to be established via alternate-protocol
1967 // without racing an HTTP connection, we need the host resolution to happen
1968 // synchronously. Of course, even though QUIC *could* perform a 0-RTT
1969 // connection to the the server, in this test we require confirmation
1970 // before encrypting so the HTTP job will still start.
1971 host_resolver_.set_synchronous_mode(true);
1972 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
1973 "");
1974 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
1975 AddressList address;
1976 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
1977 nullptr, net_log_.bound());
1978
1979 CreateSession();
1980 session_->quic_stream_factory()->set_require_confirmation(true);
1981 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
1982
1983 std::unique_ptr<HttpNetworkTransaction> trans(
1984 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1985 TestCompletionCallback callback;
1986 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:011987 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
rchcd5f1c62016-06-23 02:43:481988
1989 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
1990 QuicSession::HANDSHAKE_CONFIRMED);
1991 // Read the headers.
robpercival214763f2016-07-01 23:27:011992 EXPECT_THAT(callback.WaitForResult(), IsOk());
rchcd5f1c62016-06-23 02:43:481993
1994 const HttpResponseInfo* response = trans->GetResponseInfo();
1995 ASSERT_TRUE(response != nullptr);
1996 ASSERT_TRUE(response->headers.get() != nullptr);
1997 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
1998 EXPECT_TRUE(response->was_fetched_via_spdy);
1999 EXPECT_TRUE(response->was_npn_negotiated);
2000 EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3,
2001 response->connection_info);
2002
2003 std::string response_data;
2004 ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR,
2005 ReadTransaction(trans.get(), &response_data));
2006}
2007
2008TEST_P(QuicNetworkTransactionTest, RstSteamBeforeHeaders) {
2009 MockQuicData mock_quic_data;
2010 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
2011 1, kClientDataStreamId1, true, true,
2012 GetRequestHeaders("GET", "https", "/")));
2013 mock_quic_data.AddRead(ConstructServerRstPacket(
2014 1, false, kClientDataStreamId1, QUIC_STREAM_CANCELLED));
2015 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
2016 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
2017
2018 // The non-alternate protocol job needs to hang in order to guarantee that
2019 // the alternate-protocol job will "win".
2020 AddHangingNonAlternateProtocolSocketData();
2021
2022 // In order for a new QUIC session to be established via alternate-protocol
2023 // without racing an HTTP connection, we need the host resolution to happen
2024 // synchronously. Of course, even though QUIC *could* perform a 0-RTT
2025 // connection to the the server, in this test we require confirmation
2026 // before encrypting so the HTTP job will still start.
2027 host_resolver_.set_synchronous_mode(true);
2028 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
2029 "");
2030 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
2031 AddressList address;
2032 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
2033 nullptr, net_log_.bound());
2034
2035 CreateSession();
2036 session_->quic_stream_factory()->set_require_confirmation(true);
2037 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
2038
2039 std::unique_ptr<HttpNetworkTransaction> trans(
2040 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
2041 TestCompletionCallback callback;
2042 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:012043 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
rchcd5f1c62016-06-23 02:43:482044
2045 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
2046 QuicSession::HANDSHAKE_CONFIRMED);
2047 // Read the headers.
robpercival214763f2016-07-01 23:27:012048 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR));
rchcd5f1c62016-06-23 02:43:482049}
2050
[email protected]1e960032013-12-20 19:00:202051TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
[email protected]3316d422013-05-03 21:45:302052 // Alternate-protocol job
alyssar2adf3ac2016-05-03 17:12:582053 std::unique_ptr<QuicEncryptedPacket> close(
2054 ConstructServerConnectionClosePacket(1));
[email protected]3316d422013-05-03 21:45:302055 MockRead quic_reads[] = {
rchb27683c2015-07-29 23:53:502056 MockRead(ASYNC, close->data(), close->length()),
2057 MockRead(ASYNC, ERR_IO_PENDING), // No more data to read
2058 MockRead(ASYNC, OK), // EOF
[email protected]3316d422013-05-03 21:45:302059 };
rjshaded5ced072015-12-18 19:26:022060 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), nullptr,
2061 0);
[email protected]3316d422013-05-03 21:45:302062 socket_factory_.AddSocketDataProvider(&quic_data);
2063
2064 // Main job which will succeed even though the alternate job fails.
2065 MockRead http_reads[] = {
rjshaded5ced072015-12-18 19:26:022066 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
2067 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
2068 MockRead(ASYNC, OK)};
[email protected]3316d422013-05-03 21:45:302069
rjshaded5ced072015-12-18 19:26:022070 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
2071 0);
[email protected]3316d422013-05-03 21:45:302072 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:562073 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]3316d422013-05-03 21:45:302074
rch3f4b8452016-02-23 16:59:322075 CreateSession();
[email protected]aa9b14d2013-05-10 23:45:192076 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
2077 SendRequestAndExpectHttpResponse("hello from http");
2078 ExpectBrokenAlternateProtocolMapping();
[email protected]3316d422013-05-03 21:45:302079}
2080
[email protected]1e960032013-12-20 19:00:202081TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) {
[email protected]d03a66d2013-05-06 12:55:592082 // Alternate-protocol job
2083 MockRead quic_reads[] = {
rjshaded5ced072015-12-18 19:26:022084 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
[email protected]d03a66d2013-05-06 12:55:592085 };
rjshaded5ced072015-12-18 19:26:022086 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), nullptr,
2087 0);
[email protected]d03a66d2013-05-06 12:55:592088 socket_factory_.AddSocketDataProvider(&quic_data);
2089
2090 // Main job which will succeed even though the alternate job fails.
2091 MockRead http_reads[] = {
rjshaded5ced072015-12-18 19:26:022092 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
2093 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
2094 MockRead(ASYNC, OK)};
[email protected]d03a66d2013-05-06 12:55:592095
rjshaded5ced072015-12-18 19:26:022096 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
2097 0);
[email protected]d03a66d2013-05-06 12:55:592098 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:562099 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]d03a66d2013-05-06 12:55:592100
rch3f4b8452016-02-23 16:59:322101 CreateSession();
[email protected]d03a66d2013-05-06 12:55:592102
[email protected]aa9b14d2013-05-10 23:45:192103 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
2104 SendRequestAndExpectHttpResponse("hello from http");
2105 ExpectBrokenAlternateProtocolMapping();
[email protected]d03a66d2013-05-06 12:55:592106}
2107
[email protected]00c159f2014-05-21 22:38:162108TEST_P(QuicNetworkTransactionTest, NoBrokenAlternateProtocolIfTcpFails) {
[email protected]eb71ab62014-05-23 07:57:532109 // Alternate-protocol job will fail when the session attempts to read.
[email protected]00c159f2014-05-21 22:38:162110 MockRead quic_reads[] = {
rjshaded5ced072015-12-18 19:26:022111 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
[email protected]00c159f2014-05-21 22:38:162112 };
rjshaded5ced072015-12-18 19:26:022113 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), nullptr,
2114 0);
[email protected]00c159f2014-05-21 22:38:162115 socket_factory_.AddSocketDataProvider(&quic_data);
2116
[email protected]eb71ab62014-05-23 07:57:532117 // Main job will also fail.
[email protected]00c159f2014-05-21 22:38:162118 MockRead http_reads[] = {
rjshaded5ced072015-12-18 19:26:022119 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
[email protected]00c159f2014-05-21 22:38:162120 };
2121
rjshaded5ced072015-12-18 19:26:022122 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
2123 0);
[email protected]00c159f2014-05-21 22:38:162124 http_data.set_connect_data(MockConnect(ASYNC, ERR_SOCKET_NOT_CONNECTED));
2125 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:562126 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]00c159f2014-05-21 22:38:162127
rtennetib8e80fb2016-05-16 00:12:092128 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:322129 CreateSession();
[email protected]00c159f2014-05-21 22:38:162130
2131 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
danakjad1777e2016-04-16 00:56:422132 std::unique_ptr<HttpNetworkTransaction> trans(
[email protected]00c159f2014-05-21 22:38:162133 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
2134 TestCompletionCallback callback;
2135 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:012136 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2137 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_SOCKET_NOT_CONNECTED));
[email protected]00c159f2014-05-21 22:38:162138 ExpectQuicAlternateProtocolMapping();
2139}
2140
[email protected]1e960032013-12-20 19:00:202141TEST_P(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) {
[email protected]77c6c162013-08-17 02:57:452142 // Alternate-protocol job
2143 MockRead quic_reads[] = {
rjshaded5ced072015-12-18 19:26:022144 MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
[email protected]77c6c162013-08-17 02:57:452145 };
rjshaded5ced072015-12-18 19:26:022146 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), nullptr,
2147 0);
[email protected]77c6c162013-08-17 02:57:452148 socket_factory_.AddSocketDataProvider(&quic_data);
2149
[email protected]c92c1b52014-05-31 04:16:062150 // Second Alternate-protocol job which will race with the TCP job.
2151 StaticSocketDataProvider quic_data2(quic_reads, arraysize(quic_reads),
rtennetibe635732014-10-02 22:51:422152 nullptr, 0);
[email protected]c92c1b52014-05-31 04:16:062153 socket_factory_.AddSocketDataProvider(&quic_data2);
2154
[email protected]4d283b32013-10-17 12:57:272155 // Final job that will proceed when the QUIC job fails.
2156 MockRead http_reads[] = {
rjshaded5ced072015-12-18 19:26:022157 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
2158 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
2159 MockRead(ASYNC, OK)};
[email protected]4d283b32013-10-17 12:57:272160
rjshaded5ced072015-12-18 19:26:022161 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
2162 0);
[email protected]4d283b32013-10-17 12:57:272163 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:562164 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]4d283b32013-10-17 12:57:272165
rtennetiafccbc062016-05-16 18:21:142166 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:322167 CreateSession();
[email protected]77c6c162013-08-17 02:57:452168
2169 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
2170
[email protected]4d283b32013-10-17 12:57:272171 SendRequestAndExpectHttpResponse("hello from http");
[email protected]77c6c162013-08-17 02:57:452172
2173 ExpectBrokenAlternateProtocolMapping();
[email protected]4d283b32013-10-17 12:57:272174
rch37de576c2015-05-17 20:28:172175 EXPECT_TRUE(quic_data.AllReadDataConsumed());
2176 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
[email protected]77c6c162013-08-17 02:57:452177}
2178
[email protected]93b31772014-06-19 08:03:352179TEST_P(QuicNetworkTransactionTest, DISABLED_HangingZeroRttFallback) {
[email protected]65768442014-06-06 23:37:032180 // Alternate-protocol job
2181 MockRead quic_reads[] = {
mmenkee24011922015-12-17 22:12:592182 MockRead(SYNCHRONOUS, ERR_IO_PENDING),
[email protected]65768442014-06-06 23:37:032183 };
rjshaded5ced072015-12-18 19:26:022184 StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads), nullptr,
2185 0);
[email protected]65768442014-06-06 23:37:032186 socket_factory_.AddSocketDataProvider(&quic_data);
2187
2188 // Main job that will proceed when the QUIC job fails.
2189 MockRead http_reads[] = {
rjshaded5ced072015-12-18 19:26:022190 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
2191 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
2192 MockRead(ASYNC, OK)};
[email protected]65768442014-06-06 23:37:032193
rjshaded5ced072015-12-18 19:26:022194 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
2195 0);
[email protected]65768442014-06-06 23:37:032196 socket_factory_.AddSocketDataProvider(&http_data);
2197
rtennetib8e80fb2016-05-16 00:12:092198 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:322199 CreateSession();
[email protected]65768442014-06-06 23:37:032200
2201 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
2202
2203 SendRequestAndExpectHttpResponse("hello from http");
2204}
2205
[email protected]eb71ab62014-05-23 07:57:532206TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolOnConnectFailure) {
[email protected]4d590c9c2014-05-02 05:14:332207 // Alternate-protocol job will fail before creating a QUIC session.
rtennetibe635732014-10-02 22:51:422208 StaticSocketDataProvider quic_data(nullptr, 0, nullptr, 0);
rjshaded5ced072015-12-18 19:26:022209 quic_data.set_connect_data(
2210 MockConnect(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED));
[email protected]4d590c9c2014-05-02 05:14:332211 socket_factory_.AddSocketDataProvider(&quic_data);
2212
2213 // Main job which will succeed even though the alternate job fails.
2214 MockRead http_reads[] = {
rjshaded5ced072015-12-18 19:26:022215 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
2216 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
2217 MockRead(ASYNC, OK)};
[email protected]4d590c9c2014-05-02 05:14:332218
rjshaded5ced072015-12-18 19:26:022219 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
2220 0);
[email protected]4d590c9c2014-05-02 05:14:332221 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:562222 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]4d590c9c2014-05-02 05:14:332223
rch3f4b8452016-02-23 16:59:322224 CreateSession();
[email protected]4d590c9c2014-05-02 05:14:332225 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
2226 SendRequestAndExpectHttpResponse("hello from http");
[email protected]eb71ab62014-05-23 07:57:532227
2228 ExpectBrokenAlternateProtocolMapping();
[email protected]4d590c9c2014-05-02 05:14:332229}
2230
[email protected]4fee9672014-01-08 14:47:152231TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
[email protected]4fee9672014-01-08 14:47:152232 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:582233 mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1));
2234 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
2235 1, kClientDataStreamId1, true, true,
2236 GetRequestHeaders("GET", "https", "/")));
2237 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rcha5399e02015-04-21 19:32:042238 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
[email protected]4fee9672014-01-08 14:47:152239
2240 // When the QUIC connection fails, we will try the request again over HTTP.
2241 MockRead http_reads[] = {
bnc1c196c6e2016-05-28 13:51:482242 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
rchf114d982015-10-21 01:34:562243 MockRead("hello world"),
2244 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
2245 MockRead(ASYNC, OK)};
[email protected]4fee9672014-01-08 14:47:152246
rjshaded5ced072015-12-18 19:26:022247 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
2248 0);
[email protected]4fee9672014-01-08 14:47:152249 socket_factory_.AddSocketDataProvider(&http_data);
rchf114d982015-10-21 01:34:562250 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
[email protected]4fee9672014-01-08 14:47:152251
2252 // In order for a new QUIC session to be established via alternate-protocol
2253 // without racing an HTTP connection, we need the host resolution to happen
2254 // synchronously.
2255 host_resolver_.set_synchronous_mode(true);
rch9ae5b3b2016-02-11 00:36:292256 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
rchf114d982015-10-21 01:34:562257 "");
rch9ae5b3b2016-02-11 00:36:292258 HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
[email protected]4fee9672014-01-08 14:47:152259 AddressList address;
rjshaded5ced072015-12-18 19:26:022260 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address, CompletionCallback(),
2261 nullptr, net_log_.bound());
[email protected]4fee9672014-01-08 14:47:152262
rch3f4b8452016-02-23 16:59:322263 CreateSession();
[email protected]4fee9672014-01-08 14:47:152264 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
2265 SendRequestAndExpectHttpResponse("hello world");
2266}
2267
bnc508835902015-05-12 20:10:292268TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) {
alyssar2adf3ac2016-05-03 17:12:582269 client_maker_.set_hostname("www.example.org");
tbansal0f56a39a2016-04-07 22:03:382270 EXPECT_FALSE(
2271 test_socket_performance_watcher_factory_.rtt_notification_received());
bnc508835902015-05-12 20:10:292272 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:582273 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
2274 1, kClientDataStreamId1, true, true,
2275 GetRequestHeaders("GET", "https", "/")));
2276 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
bnc508835902015-05-12 20:10:292277 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
alyssar2adf3ac2016-05-03 17:12:582278 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
2279 false, true, 0, "hello!"));
2280 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
rchb27683c2015-07-29 23:53:502281 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data.
bnc508835902015-05-12 20:10:292282 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
2283
bncb07c05532015-05-14 19:07:202284 request_.url = GURL("https://www.example.org:443");
rtennetib8e80fb2016-05-16 00:12:092285 AddHangingNonAlternateProtocolSocketData();
rch3f4b8452016-02-23 16:59:322286 CreateSession();
bnc508835902015-05-12 20:10:292287 AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
2288 SendRequestAndExpectQuicResponse("hello!");
tbansal0f56a39a2016-04-07 22:03:382289 EXPECT_TRUE(
2290 test_socket_performance_watcher_factory_.rtt_notification_received());
bnc508835902015-05-12 20:10:292291}
2292
rtenneti56977812016-01-15 19:26:562293TEST_P(QuicNetworkTransactionTest, QuicUpload) {
rtenneti8a2f4632016-03-21 20:26:572294 params_.origins_to_force_quic_on.insert(
2295 HostPortPair::FromString("mail.example.org:443"));
rtenneti56977812016-01-15 19:26:562296
2297 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
2298 MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)};
2299 SequencedSocketData socket_data(reads, arraysize(reads), writes,
2300 arraysize(writes));
2301 socket_factory_.AddSocketDataProvider(&socket_data);
2302
rtennetib8e80fb2016-05-16 00:12:092303 // The non-alternate protocol job needs to hang in order to guarantee that
2304 // the alternate-protocol job will "win".
2305 AddHangingNonAlternateProtocolSocketData();
2306
rtenneti56977812016-01-15 19:26:562307 CreateSession();
2308 request_.method = "POST";
2309 ChunkedUploadDataStream upload_data(0);
2310 upload_data.AppendData("1", 1, true);
2311
2312 request_.upload_data_stream = &upload_data;
2313
danakjad1777e2016-04-16 00:56:422314 std::unique_ptr<HttpNetworkTransaction> trans(
rtenneti56977812016-01-15 19:26:562315 new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
2316 TestCompletionCallback callback;
2317 int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:012318 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
rtenneti56977812016-01-15 19:26:562319 EXPECT_NE(OK, callback.WaitForResult());
2320}
2321
ckrasic769733c2016-06-30 00:42:132322// Adds coverage to catch regression such as https://crbug.com/622043
2323TEST_P(QuicNetworkTransactionTest, QuicServerPush) {
2324 params_.origins_to_force_quic_on.insert(
2325 HostPortPair::FromString("mail.example.org:443"));
2326
2327 MockQuicData mock_quic_data;
2328 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
2329 1, kClientDataStreamId1, true, true,
2330 GetRequestHeaders("GET", "https", "/")));
2331 QuicStreamOffset server_header_offset = 0;
2332 mock_quic_data.AddRead(ConstructServerPushPromisePacket(
2333 1, kClientDataStreamId1, kServerDataStreamId1, false,
2334 GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_header_offset,
2335 &server_maker_));
2336 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
2337 2, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"),
2338 &server_header_offset));
2339 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1));
2340 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
2341 3, kServerDataStreamId1, false, false, GetResponseHeaders("200 OK"),
2342 &server_header_offset));
2343 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId1,
2344 false, true, 0, "hello!"));
2345 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 4, 3, 1));
2346 mock_quic_data.AddRead(ConstructServerDataPacket(
2347 5, kServerDataStreamId1, false, true, 0, "and hello!"));
2348 mock_quic_data.AddWrite(
2349 ConstructClientAckAndRstPacket(4, 4, QUIC_RST_ACKNOWLEDGEMENT, 5, 5, 1));
2350 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
2351 mock_quic_data.AddRead(ASYNC, 0); // EOF
2352 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
2353
2354 // The non-alternate protocol job needs to hang in order to guarantee that
2355 // the alternate-protocol job will "win".
2356 AddHangingNonAlternateProtocolSocketData();
2357
2358 CreateSession();
2359
2360 // PUSH_PROMISE handling in the http layer gets exercised here.
2361 SendRequestAndExpectQuicResponse("hello!");
2362
2363 request_.url = GURL("https://mail.example.org/pushed.jpg");
2364 SendRequestAndExpectQuicResponse("and hello!");
2365
2366 // Check that the NetLog was filled reasonably.
2367 TestNetLogEntry::List entries;
2368 net_log_.GetEntries(&entries);
2369 EXPECT_LT(0u, entries.size());
2370
2371 // Check that we logged a QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM
2372 int pos = ExpectLogContainsSomewhere(
2373 entries, 0, NetLog::TYPE_QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
2374 NetLog::PHASE_NONE);
2375 EXPECT_LT(0, pos);
2376}
2377
ckrasicda193a82016-07-09 00:39:362378TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) {
2379 FLAGS_quic_enable_version_35 = true;
2380 FLAGS_quic_enable_version_36 = true;
2381 params_.quic_force_hol_blocking = true;
2382 params_.origins_to_force_quic_on.insert(
2383 HostPortPair::FromString("mail.example.org:443"));
2384
2385 MockQuicData mock_quic_data;
2386
2387 QuicStreamOffset offset = 0;
2388 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
2389 1, kClientDataStreamId1, true, false,
2390 GetRequestHeaders("POST", "https", "/"), &offset));
2391
2392 std::unique_ptr<QuicEncryptedPacket> packet;
2393 if (GetParam() > QUIC_VERSION_35) {
2394 packet = ConstructClientForceHolDataPacket(2, kClientDataStreamId1, true,
2395 true, &offset, "1");
2396 } else {
2397 packet =
2398 ConstructClientDataPacket(2, kClientDataStreamId1, true, true, 0, "1");
2399 }
2400 mock_quic_data.AddWrite(std::move(packet));
2401
2402 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
2403 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
2404
2405 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
2406 false, true, 0, "hello!"));
2407
2408 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
2409
2410 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
2411 mock_quic_data.AddRead(ASYNC, 0); // EOF
2412 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
2413
2414 // The non-alternate protocol job needs to hang in order to guarantee that
2415 // the alternate-protocol job will "win".
2416 AddHangingNonAlternateProtocolSocketData();
2417
2418 CreateSession();
2419 request_.method = "POST";
2420 ChunkedUploadDataStream upload_data(0);
2421 upload_data.AppendData("1", 1, true);
2422
2423 request_.upload_data_stream = &upload_data;
2424
2425 SendRequestAndExpectQuicResponse("hello!");
2426}
2427
bnc359ed2a2016-04-29 20:43:452428class QuicNetworkTransactionWithDestinationTest
2429 : public PlatformTest,
2430 public ::testing::WithParamInterface<PoolingTestParams> {
2431 protected:
2432 QuicNetworkTransactionWithDestinationTest()
2433 : clock_(new MockClock),
2434 version_(GetParam().version),
2435 destination_type_(GetParam().destination_type),
2436 cert_transparency_verifier_(new MultiLogCTVerifier()),
2437 ssl_config_service_(new SSLConfigServiceDefaults),
2438 proxy_service_(ProxyService::CreateDirect()),
2439 auth_handler_factory_(
2440 HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
2441 random_generator_(0),
2442 ssl_data_(ASYNC, OK) {}
2443
2444 void SetUp() override {
2445 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
fdoray92e35a72016-06-10 15:54:552446 base::RunLoop().RunUntilIdle();
bnc359ed2a2016-04-29 20:43:452447
2448 HttpNetworkSession::Params params;
2449
2450 clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
2451 params.quic_clock = clock_;
2452
2453 crypto_client_stream_factory_.set_handshake_mode(
2454 MockCryptoClientStream::CONFIRM_HANDSHAKE);
2455 params.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
2456
bnc359ed2a2016-04-29 20:43:452457 params.enable_quic = true;
2458 params.quic_random = &random_generator_;
2459 params.client_socket_factory = &socket_factory_;
2460 params.host_resolver = &host_resolver_;
2461 params.cert_verifier = &cert_verifier_;
2462 params.transport_security_state = &transport_security_state_;
2463 params.cert_transparency_verifier = cert_transparency_verifier_.get();
rsleevid6de8302016-06-21 01:33:202464 params.ct_policy_enforcer = &ct_policy_enforcer_;
bnc359ed2a2016-04-29 20:43:452465 params.socket_performance_watcher_factory =
2466 &test_socket_performance_watcher_factory_;
2467 params.ssl_config_service = ssl_config_service_.get();
2468 params.proxy_service = proxy_service_.get();
2469 params.http_auth_handler_factory = auth_handler_factory_.get();
bnc525e175a2016-06-20 12:36:402470 params.http_server_properties = &http_server_properties_;
bnc359ed2a2016-04-29 20:43:452471 params.quic_supported_versions = SupportedVersions(version_);
2472 params.quic_host_whitelist.insert("news.example.org");
2473 params.quic_host_whitelist.insert("mail.example.org");
2474 params.quic_host_whitelist.insert("mail.example.com");
2475
2476 session_.reset(new HttpNetworkSession(params));
2477 session_->quic_stream_factory()->set_require_confirmation(true);
2478 ASSERT_EQ(params.quic_socket_receive_buffer_size,
2479 session_->quic_stream_factory()->socket_receive_buffer_size());
2480 }
2481
2482 void TearDown() override {
2483 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
2484 // Empty the current queue.
fdoray92e35a72016-06-10 15:54:552485 base::RunLoop().RunUntilIdle();
bnc359ed2a2016-04-29 20:43:452486 PlatformTest::TearDown();
2487 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
fdoray92e35a72016-06-10 15:54:552488 base::RunLoop().RunUntilIdle();
bnc525e175a2016-06-20 12:36:402489 session_.reset();
bnc359ed2a2016-04-29 20:43:452490 }
2491
2492 void SetAlternativeService(const std::string& origin) {
2493 HostPortPair destination;
2494 switch (destination_type_) {
2495 case SAME_AS_FIRST:
2496 destination = HostPortPair(origin1_, 443);
2497 break;
2498 case SAME_AS_SECOND:
2499 destination = HostPortPair(origin2_, 443);
2500 break;
2501 case DIFFERENT:
2502 destination = HostPortPair(kDifferentHostname, 443);
2503 break;
2504 }
2505 AlternativeService alternative_service(QUIC, destination);
2506 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
2507 http_server_properties_.SetAlternativeService(
2508 url::SchemeHostPort("https", origin, 443), alternative_service,
2509 expiration);
2510 }
2511
alyssar2adf3ac2016-05-03 17:12:582512 std::unique_ptr<QuicEncryptedPacket> ConstructClientRequestHeadersPacket(
bnc359ed2a2016-04-29 20:43:452513 QuicPacketNumber packet_number,
2514 QuicStreamId stream_id,
2515 bool should_include_version,
2516 QuicStreamOffset* offset,
2517 QuicTestPacketMaker* maker) {
2518 SpdyPriority priority =
2519 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
2520 SpdyHeaderBlock headers(maker->GetRequestHeaders("GET", "https", "/"));
2521 return maker->MakeRequestHeadersPacketWithOffsetTracking(
2522 packet_number, stream_id, should_include_version, true, priority,
bnc086b39e12016-06-24 13:05:262523 std::move(headers), offset);
bnc359ed2a2016-04-29 20:43:452524 }
2525
alyssar2adf3ac2016-05-03 17:12:582526 std::unique_ptr<QuicEncryptedPacket> ConstructClientRequestHeadersPacket(
bnc359ed2a2016-04-29 20:43:452527 QuicPacketNumber packet_number,
2528 QuicStreamId stream_id,
2529 bool should_include_version,
2530 QuicTestPacketMaker* maker) {
alyssar2adf3ac2016-05-03 17:12:582531 return ConstructClientRequestHeadersPacket(
bnc359ed2a2016-04-29 20:43:452532 packet_number, stream_id, should_include_version, nullptr, maker);
2533 }
2534
alyssar2adf3ac2016-05-03 17:12:582535 std::unique_ptr<QuicEncryptedPacket> ConstructServerResponseHeadersPacket(
bnc359ed2a2016-04-29 20:43:452536 QuicPacketNumber packet_number,
2537 QuicStreamId stream_id,
2538 QuicStreamOffset* offset,
2539 QuicTestPacketMaker* maker) {
2540 SpdyHeaderBlock headers(maker->GetResponseHeaders("200 OK"));
2541 return maker->MakeResponseHeadersPacketWithOffsetTracking(
bnc086b39e12016-06-24 13:05:262542 packet_number, stream_id, false, false, std::move(headers), offset);
bnc359ed2a2016-04-29 20:43:452543 }
2544
alyssar2adf3ac2016-05-03 17:12:582545 std::unique_ptr<QuicEncryptedPacket> ConstructServerResponseHeadersPacket(
bnc359ed2a2016-04-29 20:43:452546 QuicPacketNumber packet_number,
2547 QuicStreamId stream_id,
2548 QuicTestPacketMaker* maker) {
alyssar2adf3ac2016-05-03 17:12:582549 return ConstructServerResponseHeadersPacket(packet_number, stream_id,
2550 nullptr, maker);
bnc359ed2a2016-04-29 20:43:452551 }
2552
alyssar2adf3ac2016-05-03 17:12:582553 std::unique_ptr<QuicEncryptedPacket> ConstructServerDataPacket(
bnc359ed2a2016-04-29 20:43:452554 QuicPacketNumber packet_number,
2555 QuicStreamId stream_id,
2556 QuicTestPacketMaker* maker) {
2557 return maker->MakeDataPacket(packet_number, stream_id, false, true, 0,
2558 "hello");
2559 }
2560
alyssar2adf3ac2016-05-03 17:12:582561 std::unique_ptr<QuicEncryptedPacket> ConstructClientAckPacket(
bnc359ed2a2016-04-29 20:43:452562 QuicPacketNumber packet_number,
2563 QuicPacketNumber largest_received,
2564 QuicPacketNumber ack_least_unacked,
2565 QuicPacketNumber stop_least_unacked,
2566 QuicTestPacketMaker* maker) {
2567 return maker->MakeAckPacket(packet_number, largest_received,
2568 ack_least_unacked, stop_least_unacked, true);
2569 }
2570
2571 void AddRefusedSocketData() {
2572 std::unique_ptr<StaticSocketDataProvider> refused_data(
2573 new StaticSocketDataProvider());
2574 MockConnect refused_connect(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
2575 refused_data->set_connect_data(refused_connect);
2576 socket_factory_.AddSocketDataProvider(refused_data.get());
2577 static_socket_data_provider_vector_.push_back(std::move(refused_data));
2578 }
2579
2580 void AddHangingSocketData() {
2581 std::unique_ptr<StaticSocketDataProvider> hanging_data(
2582 new StaticSocketDataProvider());
2583 MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
2584 hanging_data->set_connect_data(hanging_connect);
2585 socket_factory_.AddSocketDataProvider(hanging_data.get());
2586 static_socket_data_provider_vector_.push_back(std::move(hanging_data));
2587 socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
2588 }
2589
2590 bool AllDataConsumed() {
2591 for (const auto& socket_data_ptr : static_socket_data_provider_vector_) {
2592 if (!socket_data_ptr->AllReadDataConsumed() ||
2593 !socket_data_ptr->AllWriteDataConsumed()) {
2594 return false;
2595 }
2596 }
2597 return true;
2598 }
2599
2600 void SendRequestAndExpectQuicResponse(const std::string& host) {
2601 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
2602 HttpRequestInfo request;
2603 std::string url("https://");
2604 url.append(host);
2605 request.url = GURL(url);
2606 request.load_flags = 0;
2607 request.method = "GET";
2608 TestCompletionCallback callback;
2609 int rv = trans.Start(&request, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:012610 EXPECT_THAT(callback.GetResult(rv), IsOk());
bnc359ed2a2016-04-29 20:43:452611
2612 std::string response_data;
robpercival214763f2016-07-01 23:27:012613 ASSERT_THAT(ReadTransaction(&trans, &response_data), IsOk());
bnc359ed2a2016-04-29 20:43:452614 EXPECT_EQ("hello", response_data);
2615
2616 const HttpResponseInfo* response = trans.GetResponseInfo();
2617 ASSERT_TRUE(response != nullptr);
2618 ASSERT_TRUE(response->headers.get() != nullptr);
2619 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
2620 EXPECT_TRUE(response->was_fetched_via_spdy);
2621 EXPECT_TRUE(response->was_npn_negotiated);
2622 EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3,
2623 response->connection_info);
2624 EXPECT_EQ(443, response->socket_address.port());
2625 }
2626
2627 MockClock* clock_;
2628 QuicVersion version_;
2629 DestinationType destination_type_;
2630 std::string origin1_;
2631 std::string origin2_;
2632 std::unique_ptr<HttpNetworkSession> session_;
2633 MockClientSocketFactory socket_factory_;
2634 MockHostResolver host_resolver_;
2635 MockCertVerifier cert_verifier_;
2636 TransportSecurityState transport_security_state_;
2637 std::unique_ptr<CTVerifier> cert_transparency_verifier_;
rsleevid6de8302016-06-21 01:33:202638 CTPolicyEnforcer ct_policy_enforcer_;
bnc359ed2a2016-04-29 20:43:452639 TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_;
2640 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
2641 std::unique_ptr<ProxyService> proxy_service_;
2642 std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
2643 MockRandom random_generator_;
2644 HttpServerPropertiesImpl http_server_properties_;
2645 BoundTestNetLog net_log_;
2646 MockCryptoClientStreamFactory crypto_client_stream_factory_;
2647 std::vector<std::unique_ptr<StaticSocketDataProvider>>
2648 static_socket_data_provider_vector_;
2649 SSLSocketDataProvider ssl_data_;
2650};
2651
2652INSTANTIATE_TEST_CASE_P(Version,
2653 QuicNetworkTransactionWithDestinationTest,
2654 ::testing::ValuesIn(GetPoolingTestParams()));
2655
2656// A single QUIC request fails because the certificate does not match the origin
2657// hostname, regardless of whether it matches the alternative service hostname.
2658TEST_P(QuicNetworkTransactionWithDestinationTest, InvalidCertificate) {
2659 if (destination_type_ == DIFFERENT)
2660 return;
2661
2662 GURL url("https://mail.example.com/");
2663 origin1_ = url.host();
2664
2665 // Not used for requests, but this provides a test case where the certificate
2666 // is valid for the hostname of the alternative service.
2667 origin2_ = "mail.example.org";
2668
2669 SetAlternativeService(origin1_);
2670
2671 scoped_refptr<X509Certificate> cert(
2672 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
2673 bool unused;
2674 ASSERT_FALSE(cert->VerifyNameMatch(origin1_, &unused));
2675 ASSERT_TRUE(cert->VerifyNameMatch(origin2_, &unused));
2676
2677 ProofVerifyDetailsChromium verify_details;
2678 verify_details.cert_verify_result.verified_cert = cert;
2679 verify_details.cert_verify_result.is_issued_by_known_root = true;
2680 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2681
2682 MockQuicData mock_quic_data;
2683 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);
2684 mock_quic_data.AddRead(ASYNC, 0);
2685
2686 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
2687
2688 AddRefusedSocketData();
2689
2690 HttpRequestInfo request;
2691 request.url = url;
2692
2693 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
2694 TestCompletionCallback callback;
2695 int rv = trans.Start(&request, callback.callback(), net_log_.bound());
robpercival214763f2016-07-01 23:27:012696 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED));
bnc359ed2a2016-04-29 20:43:452697
2698 EXPECT_TRUE(AllDataConsumed());
2699}
2700
2701// First request opens QUIC session to alternative service. Second request
2702// pools to it, because destination matches and certificate is valid, even
2703// though QuicServerId is different.
2704TEST_P(QuicNetworkTransactionWithDestinationTest, PoolIfCertificateValid) {
2705 origin1_ = "mail.example.org";
2706 origin2_ = "news.example.org";
2707
2708 SetAlternativeService(origin1_);
2709 SetAlternativeService(origin2_);
2710
2711 scoped_refptr<X509Certificate> cert(
2712 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
2713 bool unused;
2714 ASSERT_TRUE(cert->VerifyNameMatch(origin1_, &unused));
2715 ASSERT_TRUE(cert->VerifyNameMatch(origin2_, &unused));
2716 ASSERT_FALSE(cert->VerifyNameMatch(kDifferentHostname, &unused));
2717
2718 ProofVerifyDetailsChromium verify_details;
2719 verify_details.cert_verify_result.verified_cert = cert;
2720 verify_details.cert_verify_result.is_issued_by_known_root = true;
2721 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2722
alyssar2adf3ac2016-05-03 17:12:582723 QuicTestPacketMaker client_maker1(version_, 0, clock_, origin1_,
2724 Perspective::IS_CLIENT);
2725 QuicTestPacketMaker server_maker1(version_, 0, clock_, origin1_,
2726 Perspective::IS_SERVER);
bnc359ed2a2016-04-29 20:43:452727
2728 QuicStreamOffset request_header_offset(0);
2729 QuicStreamOffset response_header_offset(0);
2730
2731 MockQuicData mock_quic_data;
alyssar2adf3ac2016-05-03 17:12:582732 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
2733 1, kClientDataStreamId1, true, &request_header_offset, &client_maker1));
2734 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
2735 1, kClientDataStreamId1, &response_header_offset, &server_maker1));
2736 mock_quic_data.AddRead(
2737 ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker1));
2738 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1, &client_maker1));
bnc359ed2a2016-04-29 20:43:452739
alyssar2adf3ac2016-05-03 17:12:582740 QuicTestPacketMaker client_maker2(version_, 0, clock_, origin2_,
2741 Perspective::IS_CLIENT);
2742 QuicTestPacketMaker server_maker2(version_, 0, clock_, origin2_,
2743 Perspective::IS_SERVER);
bnc359ed2a2016-04-29 20:43:452744
alyssar2adf3ac2016-05-03 17:12:582745 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
2746 3, kClientDataStreamId2, false, &request_header_offset, &client_maker2));
2747 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
2748 3, kClientDataStreamId2, &response_header_offset, &server_maker2));
2749 mock_quic_data.AddRead(
2750 ConstructServerDataPacket(4, kClientDataStreamId2, &server_maker2));
2751 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1, &client_maker2));
bnc359ed2a2016-04-29 20:43:452752 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
2753 mock_quic_data.AddRead(ASYNC, 0); // EOF
2754
2755 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
2756
2757 AddHangingSocketData();
2758 AddHangingSocketData();
2759
2760 SendRequestAndExpectQuicResponse(origin1_);
2761 SendRequestAndExpectQuicResponse(origin2_);
2762
2763 EXPECT_TRUE(AllDataConsumed());
2764}
2765
2766// First request opens QUIC session to alternative service. Second request does
2767// not pool to it, even though destination matches, because certificate is not
2768// valid. Instead, a new QUIC session is opened to the same destination with a
2769// different QuicServerId.
2770TEST_P(QuicNetworkTransactionWithDestinationTest,
2771 DoNotPoolIfCertificateInvalid) {
2772 origin1_ = "news.example.org";
2773 origin2_ = "mail.example.com";
2774
2775 SetAlternativeService(origin1_);
2776 SetAlternativeService(origin2_);
2777
2778 scoped_refptr<X509Certificate> cert1(
2779 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
2780 bool unused;
2781 ASSERT_TRUE(cert1->VerifyNameMatch(origin1_, &unused));
2782 ASSERT_FALSE(cert1->VerifyNameMatch(origin2_, &unused));
2783 ASSERT_FALSE(cert1->VerifyNameMatch(kDifferentHostname, &unused));
2784
2785 scoped_refptr<X509Certificate> cert2(
2786 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
2787 ASSERT_TRUE(cert2->VerifyNameMatch(origin2_, &unused));
2788 ASSERT_FALSE(cert2->VerifyNameMatch(kDifferentHostname, &unused));
2789
2790 ProofVerifyDetailsChromium verify_details1;
2791 verify_details1.cert_verify_result.verified_cert = cert1;
2792 verify_details1.cert_verify_result.is_issued_by_known_root = true;
2793 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1);
2794
2795 ProofVerifyDetailsChromium verify_details2;
2796 verify_details2.cert_verify_result.verified_cert = cert2;
2797 verify_details2.cert_verify_result.is_issued_by_known_root = true;
2798 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
2799
alyssar2adf3ac2016-05-03 17:12:582800 QuicTestPacketMaker client_maker1(version_, 0, clock_, origin1_,
2801 Perspective::IS_CLIENT);
2802 QuicTestPacketMaker server_maker1(version_, 0, clock_, origin1_,
2803 Perspective::IS_SERVER);
bnc359ed2a2016-04-29 20:43:452804
2805 MockQuicData mock_quic_data1;
alyssar2adf3ac2016-05-03 17:12:582806 mock_quic_data1.AddWrite(ConstructClientRequestHeadersPacket(
2807 1, kClientDataStreamId1, true, &client_maker1));
2808 mock_quic_data1.AddRead(ConstructServerResponseHeadersPacket(
2809 1, kClientDataStreamId1, &server_maker1));
2810 mock_quic_data1.AddRead(
2811 ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker1));
bnc359ed2a2016-04-29 20:43:452812 mock_quic_data1.AddWrite(
alyssar2adf3ac2016-05-03 17:12:582813 ConstructClientAckPacket(2, 2, 1, 1, &client_maker1));
bnc359ed2a2016-04-29 20:43:452814 mock_quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
2815 mock_quic_data1.AddRead(ASYNC, 0); // EOF
2816
2817 mock_quic_data1.AddSocketDataToFactory(&socket_factory_);
2818
2819 AddHangingSocketData();
2820
alyssar2adf3ac2016-05-03 17:12:582821 QuicTestPacketMaker client_maker2(version_, 0, clock_, origin2_,
2822 Perspective::IS_CLIENT);
2823 QuicTestPacketMaker server_maker2(version_, 0, clock_, origin2_,
2824 Perspective::IS_SERVER);
bnc359ed2a2016-04-29 20:43:452825
2826 MockQuicData mock_quic_data2;
alyssar2adf3ac2016-05-03 17:12:582827 mock_quic_data2.AddWrite(ConstructClientRequestHeadersPacket(
2828 1, kClientDataStreamId1, true, &client_maker2));
2829 mock_quic_data2.AddRead(ConstructServerResponseHeadersPacket(
2830 1, kClientDataStreamId1, &server_maker2));
2831 mock_quic_data2.AddRead(
2832 ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker2));
bnc359ed2a2016-04-29 20:43:452833 mock_quic_data2.AddWrite(
alyssar2adf3ac2016-05-03 17:12:582834 ConstructClientAckPacket(2, 2, 1, 1, &client_maker2));
bnc359ed2a2016-04-29 20:43:452835 mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
2836 mock_quic_data2.AddRead(ASYNC, 0); // EOF
2837
2838 mock_quic_data2.AddSocketDataToFactory(&socket_factory_);
2839
2840 AddHangingSocketData();
2841
2842 SendRequestAndExpectQuicResponse(origin1_);
2843 SendRequestAndExpectQuicResponse(origin2_);
2844
2845 EXPECT_TRUE(AllDataConsumed());
2846}
2847
[email protected]61a527782013-02-21 03:58:002848} // namespace test
2849} // namespace net