1 // Copyright 2017 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/quic/quic_proxy_client_socket.h"
6
7 #include <memory>
8 #include <tuple>
9 #include <utility>
10 #include <vector>
11
12 #include "base/functional/bind.h"
13 #include "base/memory/ptr_util.h"
14 #include "base/memory/raw_ptr.h"
15 #include "base/run_loop.h"
16 #include "base/strings/strcat.h"
17 #include "base/strings/utf_string_conversions.h"
18 #include "base/task/single_thread_task_runner.h"
19 #include "base/time/default_tick_clock.h"
20 #include "net/base/proxy_server.h"
21 #include "net/base/proxy_string_util.h"
22 #include "net/base/test_proxy_delegate.h"
23 #include "net/dns/mock_host_resolver.h"
24 #include "net/dns/public/host_resolver_results.h"
25 #include "net/dns/public/secure_dns_policy.h"
26 #include "net/http/http_auth_cache.h"
27 #include "net/http/http_auth_handler_factory.h"
28 #include "net/http/http_response_headers.h"
29 #include "net/http/transport_security_state.h"
30 #include "net/log/net_log.h"
31 #include "net/log/test_net_log.h"
32 #include "net/log/test_net_log_util.h"
33 #include "net/quic/address_utils.h"
34 #include "net/quic/crypto/proof_verifier_chromium.h"
35 #include "net/quic/mock_crypto_client_stream_factory.h"
36 #include "net/quic/mock_quic_data.h"
37 #include "net/quic/quic_chromium_alarm_factory.h"
38 #include "net/quic/quic_chromium_client_session.h"
39 #include "net/quic/quic_chromium_connection_helper.h"
40 #include "net/quic/quic_chromium_packet_writer.h"
41 #include "net/quic/quic_context.h"
42 #include "net/quic/quic_crypto_client_config_handle.h"
43 #include "net/quic/quic_http_utils.h"
44 #include "net/quic/quic_server_info.h"
45 #include "net/quic/quic_stream_factory.h"
46 #include "net/quic/quic_test_packet_maker.h"
47 #include "net/quic/test_quic_crypto_client_config_handle.h"
48 #include "net/quic/test_task_runner.h"
49 #include "net/socket/socket_test_util.h"
50 #include "net/ssl/ssl_config_service_defaults.h"
51 #include "net/test/cert_test_util.h"
52 #include "net/test/gtest_util.h"
53 #include "net/test/test_data_directory.h"
54 #include "net/test/test_with_task_environment.h"
55 #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
56 #include "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.h"
57 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_clock.h"
58 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_connection_id_generator.h"
59 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h"
60 #include "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_test_utils.h"
61 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_connection_peer.h"
62 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
63 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
64 #include "testing/gmock/include/gmock/gmock.h"
65 #include "testing/gtest/include/gtest/gtest.h"
66 #include "url/gurl.h"
67 #include "url/scheme_host_port.h"
68 #include "url/url_constants.h"
69
70 using testing::_;
71 using testing::AnyNumber;
72 using testing::Return;
73
74 namespace net::test {
75
76 namespace {
77
78 static const char kOriginHost[] = "www.google.com";
79 static const int kOriginPort = 443;
80 static const char kProxyUrl[] = "https://myproxy:6121/";
81 static const char kProxyHost[] = "myproxy";
82 static const int kProxyPort = 6121;
83 static const char kUserAgent[] = "Mozilla/1.0";
84 static const char kRedirectUrl[] = "https://example.com/";
85
86 static const char kMsg1[] = "\0hello!\xff";
87 static const int kLen1 = 8;
88 static const char kMsg2[] = "\0a2345678\0";
89 static const int kLen2 = 10;
90 static const char kMsg3[] = "bye!";
91 static const int kLen3 = 4;
92 static const char kMsg33[] = "bye!bye!";
93 static const int kLen33 = kLen3 + kLen3;
94 static const char kMsg333[] = "bye!bye!bye!";
95 static const int kLen333 = kLen3 + kLen3 + kLen3;
96
97 static constexpr int k0ByteConnectionId = 0;
98 static constexpr int k8ByteConnectionId = 8;
99
100 } // anonymous namespace
101
102 class QuicProxyClientSocketTest
103 : public ::testing::TestWithParam<quic::ParsedQuicVersion>,
104 public WithTaskEnvironment {
105 protected:
106 static const bool kFin = true;
107 static const bool kIncludeVersion = true;
108 static const bool kIncludeDiversificationNonce = true;
109
GetStreamFrameDataLengthFromPacketLength(quic::QuicByteCount packet_length,quic::ParsedQuicVersion version,bool include_version,bool include_diversification_nonce,int connection_id_length,quic::QuicPacketNumberLength packet_number_length,quic::QuicStreamOffset offset)110 static size_t GetStreamFrameDataLengthFromPacketLength(
111 quic::QuicByteCount packet_length,
112 quic::ParsedQuicVersion version,
113 bool include_version,
114 bool include_diversification_nonce,
115 int connection_id_length,
116 quic::QuicPacketNumberLength packet_number_length,
117 quic::QuicStreamOffset offset) {
118 quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
119 quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
120 quiche::QuicheVariableLengthIntegerLength length_length =
121 quic::QuicVersionHasLongHeaderLengths(version.transport_version) &&
122 include_version
123 ? quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2
124 : quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
125 size_t min_data_length = 1;
126 size_t min_packet_length =
127 quic::test::TaggingEncrypter(quic::ENCRYPTION_FORWARD_SECURE)
128 .GetCiphertextSize(min_data_length) +
129 quic::QuicPacketCreator::StreamFramePacketOverhead(
130 version.transport_version, k8ByteConnectionId, k0ByteConnectionId,
131 include_version, include_diversification_nonce,
132 packet_number_length, retry_token_length_length, length_length,
133 offset);
134
135 DCHECK(packet_length >= min_packet_length);
136 return min_data_length + packet_length - min_packet_length;
137 }
138
QuicProxyClientSocketTest()139 QuicProxyClientSocketTest()
140 : version_(GetParam()),
141 client_data_stream_id1_(quic::QuicUtils::GetFirstBidirectionalStreamId(
142 version_.transport_version,
143 quic::Perspective::IS_CLIENT)),
144 mock_quic_data_(version_),
145 crypto_config_(
146 quic::test::crypto_test_utils::ProofVerifierForTesting()),
147 connection_id_(quic::test::TestConnectionId(2)),
148 client_maker_(version_,
149 connection_id_,
150 &clock_,
151 kProxyHost,
152 quic::Perspective::IS_CLIENT),
153 server_maker_(version_,
154 connection_id_,
155 &clock_,
156 kProxyHost,
157 quic::Perspective::IS_SERVER,
158 false),
159 user_agent_(kUserAgent),
160 proxy_endpoint_(url::kHttpsScheme, kProxyHost, kProxyPort),
161 destination_endpoint_(url::kHttpsScheme, kOriginHost, kOriginPort),
162 http_auth_cache_(
163 false /* key_server_entries_by_network_anonymization_key */),
164 host_resolver_(std::make_unique<MockCachingHostResolver>()),
165 http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()) {
166 FLAGS_quic_enable_http3_grease_randomness = false;
167 IPAddress ip(192, 0, 2, 33);
168 peer_addr_ = IPEndPoint(ip, 443);
169 clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20));
170 quic::QuicEnableVersion(version_);
171 }
172
173 QuicProxyClientSocketTest(const QuicProxyClientSocketTest&) = delete;
174 QuicProxyClientSocketTest& operator=(const QuicProxyClientSocketTest&) =
175 delete;
176
SetUp()177 void SetUp() override {}
178
TearDown()179 void TearDown() override {
180 sock_.reset();
181 EXPECT_TRUE(mock_quic_data_.AllReadDataConsumed());
182 EXPECT_TRUE(mock_quic_data_.AllWriteDataConsumed());
183 }
184
Initialize()185 void Initialize() {
186 auto socket = std::make_unique<MockUDPClientSocket>(
187 mock_quic_data_.InitializeAndGetSequencedSocketData(), NetLog::Get());
188 socket->Connect(peer_addr_);
189 runner_ = base::MakeRefCounted<TestTaskRunner>(&clock_);
190 send_algorithm_ = new quic::test::MockSendAlgorithm();
191 EXPECT_CALL(*send_algorithm_, InRecovery()).WillRepeatedly(Return(false));
192 EXPECT_CALL(*send_algorithm_, InSlowStart()).WillRepeatedly(Return(false));
193 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
194 .Times(testing::AtLeast(1));
195 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
196 .WillRepeatedly(Return(quic::kMaxOutgoingPacketSize));
197 EXPECT_CALL(*send_algorithm_, PacingRate(_))
198 .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
199 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
200 EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
201 .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
202 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
203 EXPECT_CALL(*send_algorithm_, OnApplicationLimited(_)).Times(AnyNumber());
204 EXPECT_CALL(*send_algorithm_, GetCongestionControlType())
205 .Times(AnyNumber());
206 helper_ = std::make_unique<QuicChromiumConnectionHelper>(
207 &clock_, &random_generator_);
208 alarm_factory_ =
209 std::make_unique<QuicChromiumAlarmFactory>(runner_.get(), &clock_);
210
211 QuicChromiumPacketWriter* writer = new QuicChromiumPacketWriter(
212 socket.get(), base::SingleThreadTaskRunner::GetCurrentDefault().get());
213 quic::QuicConnection* connection = new quic::QuicConnection(
214 connection_id_, quic::QuicSocketAddress(),
215 net::ToQuicSocketAddress(peer_addr_), helper_.get(),
216 alarm_factory_.get(), writer, true /* owns_writer */,
217 quic::Perspective::IS_CLIENT, quic::test::SupportedVersions(version_),
218 connection_id_generator_);
219 connection->set_visitor(&visitor_);
220 quic::test::QuicConnectionPeer::SetSendAlgorithm(connection,
221 send_algorithm_);
222
223 // Load a certificate that is valid for *.example.org
224 scoped_refptr<X509Certificate> test_cert(
225 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
226 EXPECT_TRUE(test_cert.get());
227
228 verify_details_.cert_verify_result.verified_cert = test_cert;
229 verify_details_.cert_verify_result.is_issued_by_known_root = true;
230 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
231
232 base::TimeTicks dns_end = base::TimeTicks::Now();
233 base::TimeTicks dns_start = dns_end - base::Milliseconds(1);
234
235 session_ = std::make_unique<QuicChromiumClientSession>(
236 connection, std::move(socket),
237 /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
238 &transport_security_state_, &ssl_config_service_,
239 base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
240 QuicSessionKey("mail.example.org", 80, PRIVACY_MODE_DISABLED,
241 SocketTag(), NetworkAnonymizationKey(),
242 SecureDnsPolicy::kAllow,
243 /*require_dns_https_alpn=*/false),
244 /*require_confirmation=*/false,
245 /*migrate_session_early_v2=*/false,
246 /*migrate_session_on_network_change_v2=*/false,
247 /*default_network=*/handles::kInvalidNetworkHandle,
248 quic::QuicTime::Delta::FromMilliseconds(
249 kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
250 /*migrate_idle_session=*/true, /*allow_port_migration=*/false,
251 kDefaultIdleSessionMigrationPeriod, kMaxTimeOnNonDefaultNetwork,
252 kMaxMigrationsToNonDefaultNetworkOnWriteError,
253 kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
254 kQuicYieldAfterPacketsRead,
255 quic::QuicTime::Delta::FromMilliseconds(
256 kQuicYieldAfterDurationMilliseconds),
257 /*cert_verify_flags=*/0, quic::test::DefaultQuicConfig(),
258 std::make_unique<TestQuicCryptoClientConfigHandle>(&crypto_config_),
259 "CONNECTION_UNKNOWN", dns_start, dns_end,
260 std::make_unique<quic::QuicClientPushPromiseIndex>(), nullptr,
261 base::DefaultTickClock::GetInstance(),
262 base::SingleThreadTaskRunner::GetCurrentDefault().get(),
263 /*socket_performance_watcher=*/nullptr, HostResolverEndpointResult(),
264 NetLog::Get());
265
266 writer->set_delegate(session_.get());
267
268 session_->Initialize();
269
270 // Blackhole QPACK decoder stream instead of constructing mock writes.
271 session_->qpack_decoder()->set_qpack_stream_sender_delegate(
272 &noop_qpack_stream_sender_delegate_);
273
274 TestCompletionCallback callback;
275 EXPECT_THAT(session_->CryptoConnect(callback.callback()), IsOk());
276 EXPECT_TRUE(session_->OneRttKeysAvailable());
277
278 session_handle_ = session_->CreateHandle(
279 url::SchemeHostPort(url::kHttpsScheme, "mail.example.org", 80));
280 EXPECT_THAT(session_handle_->RequestStream(true, callback.callback(),
281 TRAFFIC_ANNOTATION_FOR_TESTS),
282 IsOk());
283 std::unique_ptr<QuicChromiumClientStream::Handle> stream_handle =
284 session_handle_->ReleaseStream();
285 EXPECT_TRUE(stream_handle->IsOpen());
286
287 sock_ = std::make_unique<QuicProxyClientSocket>(
288 std::move(stream_handle), std::move(session_handle_),
289 // TODO(crbug.com/1206799) Construct `ProxyServer` with plain
290 // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
291 ProxyServer(ProxyServer::SCHEME_HTTPS,
292 HostPortPair::FromSchemeHostPort(proxy_endpoint_)),
293 user_agent_,
294 // TODO(crbug.com/1206799) Construct `QuicProxyClientSocket` with plain
295 // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
296 HostPortPair::FromSchemeHostPort(destination_endpoint_),
297 NetLogWithSource::Make(NetLogSourceType::NONE),
298 base::MakeRefCounted<HttpAuthController>(
299 HttpAuth::AUTH_PROXY, proxy_endpoint_.GetURL(),
300 NetworkAnonymizationKey(), &http_auth_cache_,
301 http_auth_handler_factory_.get(), host_resolver_.get()),
302 proxy_delegate_.get());
303
304 session_->StartReading();
305 }
306
PopulateConnectRequestIR(spdy::Http2HeaderBlock * block)307 void PopulateConnectRequestIR(spdy::Http2HeaderBlock* block) {
308 (*block)[":method"] = "CONNECT";
309 (*block)[":authority"] =
310 HostPortPair::FromSchemeHostPort(destination_endpoint_).ToString();
311 (*block)["user-agent"] = kUserAgent;
312 }
313
314 // Helper functions for constructing packets sent by the client
315
ConstructSettingsPacket(uint64_t packet_number)316 std::unique_ptr<quic::QuicReceivedPacket> ConstructSettingsPacket(
317 uint64_t packet_number) {
318 return client_maker_.MakeInitialSettingsPacket(packet_number);
319 }
320
ConstructAckAndRstOnlyPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code,uint64_t largest_received,uint64_t smallest_received)321 std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndRstOnlyPacket(
322 uint64_t packet_number,
323 quic::QuicRstStreamErrorCode error_code,
324 uint64_t largest_received,
325 uint64_t smallest_received) {
326 return client_maker_.MakeAckAndRstPacket(
327 packet_number, !kIncludeVersion, client_data_stream_id1_, error_code,
328 largest_received, smallest_received,
329 /*include_stop_sending_if_v99=*/false);
330 }
331
ConstructAckAndRstPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code,uint64_t largest_received,uint64_t smallest_received)332 std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndRstPacket(
333 uint64_t packet_number,
334 quic::QuicRstStreamErrorCode error_code,
335 uint64_t largest_received,
336 uint64_t smallest_received) {
337 return client_maker_.MakeAckAndRstPacket(
338 packet_number, !kIncludeVersion, client_data_stream_id1_, error_code,
339 largest_received, smallest_received,
340 /*include_stop_sending_if_v99=*/true);
341 }
342
ConstructRstPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code)343 std::unique_ptr<quic::QuicReceivedPacket> ConstructRstPacket(
344 uint64_t packet_number,
345 quic::QuicRstStreamErrorCode error_code) {
346 return client_maker_.MakeRstPacket(packet_number, !kIncludeVersion,
347 client_data_stream_id1_, error_code,
348 /*include_stop_sending_if_v99=*/true);
349 }
350
ConstructConnectRequestPacket(uint64_t packet_number,RequestPriority request_priority=LOWEST)351 std::unique_ptr<quic::QuicReceivedPacket> ConstructConnectRequestPacket(
352 uint64_t packet_number,
353 RequestPriority request_priority = LOWEST) {
354 spdy::Http2HeaderBlock block;
355 PopulateConnectRequestIR(&block);
356 return client_maker_.MakeRequestHeadersPacket(
357 packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
358 ConvertRequestPriorityToQuicPriority(request_priority),
359 std::move(block), nullptr);
360 }
361
362 std::unique_ptr<quic::QuicReceivedPacket>
ConstructConnectRequestPacketWithExtraHeaders(uint64_t packet_number,std::vector<std::pair<std::string,std::string>> extra_headers,RequestPriority request_priority=LOWEST)363 ConstructConnectRequestPacketWithExtraHeaders(
364 uint64_t packet_number,
365 std::vector<std::pair<std::string, std::string>> extra_headers,
366 RequestPriority request_priority = LOWEST) {
367 spdy::Http2HeaderBlock block;
368 block[":method"] = "CONNECT";
369 block[":authority"] =
370 HostPortPair::FromSchemeHostPort(destination_endpoint_).ToString();
371 for (const auto& header : extra_headers) {
372 block[header.first] = header.second;
373 }
374 return client_maker_.MakeRequestHeadersPacket(
375 packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
376 ConvertRequestPriorityToQuicPriority(request_priority),
377 std::move(block), nullptr);
378 }
379
ConstructConnectAuthRequestPacket(uint64_t packet_number)380 std::unique_ptr<quic::QuicReceivedPacket> ConstructConnectAuthRequestPacket(
381 uint64_t packet_number) {
382 RequestPriority request_priority = LOWEST;
383 spdy::Http2HeaderBlock block;
384 PopulateConnectRequestIR(&block);
385 block["proxy-authorization"] = "Basic Zm9vOmJhcg==";
386 return client_maker_.MakeRequestHeadersPacket(
387 packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
388 ConvertRequestPriorityToQuicPriority(request_priority),
389 std::move(block), nullptr);
390 }
391
ConstructDataPacket(uint64_t packet_number,absl::string_view data)392 std::unique_ptr<quic::QuicReceivedPacket> ConstructDataPacket(
393 uint64_t packet_number,
394 absl::string_view data) {
395 return client_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
396 !kIncludeVersion, !kFin, data);
397 }
398
ConstructAckAndDataPacket(uint64_t packet_number,uint64_t largest_received,uint64_t smallest_received,absl::string_view data)399 std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndDataPacket(
400 uint64_t packet_number,
401 uint64_t largest_received,
402 uint64_t smallest_received,
403 absl::string_view data) {
404 return client_maker_.MakeAckAndDataPacket(
405 packet_number, !kIncludeVersion, client_data_stream_id1_,
406 largest_received, smallest_received, !kFin, data);
407 }
408
ConstructAckPacket(uint64_t packet_number,uint64_t largest_received,uint64_t smallest_received)409 std::unique_ptr<quic::QuicReceivedPacket> ConstructAckPacket(
410 uint64_t packet_number,
411 uint64_t largest_received,
412 uint64_t smallest_received) {
413 return client_maker_.MakeAckPacket(packet_number, largest_received,
414 smallest_received);
415 }
416
417 // Helper functions for constructing packets sent by the server
418
ConstructServerRstPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code)419 std::unique_ptr<quic::QuicReceivedPacket> ConstructServerRstPacket(
420 uint64_t packet_number,
421 quic::QuicRstStreamErrorCode error_code) {
422 return server_maker_.MakeRstPacket(packet_number, !kIncludeVersion,
423 client_data_stream_id1_, error_code,
424 /*include_stop_sending_if_v99=*/true);
425 }
426
ConstructServerDataPacket(uint64_t packet_number,absl::string_view data)427 std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataPacket(
428 uint64_t packet_number,
429 absl::string_view data) {
430 return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
431 !kIncludeVersion, !kFin, data);
432 }
433
ConstructServerDataFinPacket(uint64_t packet_number,absl::string_view data)434 std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataFinPacket(
435 uint64_t packet_number,
436 absl::string_view data) {
437 return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
438 !kIncludeVersion, kFin, data);
439 }
440
ConstructServerConnectReplyPacket(uint64_t packet_number,bool fin,size_t * header_length=nullptr)441 std::unique_ptr<quic::QuicReceivedPacket> ConstructServerConnectReplyPacket(
442 uint64_t packet_number,
443 bool fin,
444 size_t* header_length = nullptr) {
445 spdy::Http2HeaderBlock block;
446 block[":status"] = "200";
447
448 return server_maker_.MakeResponseHeadersPacket(
449 packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
450 std::move(block), header_length);
451 }
452
453 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectReplyPacketWithExtraHeaders(uint64_t packet_number,bool fin,std::vector<std::pair<std::string,std::string>> extra_headers)454 ConstructServerConnectReplyPacketWithExtraHeaders(
455 uint64_t packet_number,
456 bool fin,
457 std::vector<std::pair<std::string, std::string>> extra_headers) {
458 spdy::Http2HeaderBlock block;
459 block[":status"] = "200";
460 for (const auto& header : extra_headers) {
461 block[header.first] = header.second;
462 }
463
464 return server_maker_.MakeResponseHeadersPacket(
465 packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
466 std::move(block), nullptr);
467 }
468
469 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectAuthReplyPacket(uint64_t packet_number,bool fin)470 ConstructServerConnectAuthReplyPacket(uint64_t packet_number, bool fin) {
471 spdy::Http2HeaderBlock block;
472 block[":status"] = "407";
473 block["proxy-authenticate"] = "Basic realm=\"MyRealm1\"";
474 return server_maker_.MakeResponseHeadersPacket(
475 packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
476 std::move(block), nullptr);
477 }
478
479 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectRedirectReplyPacket(uint64_t packet_number,bool fin)480 ConstructServerConnectRedirectReplyPacket(uint64_t packet_number, bool fin) {
481 spdy::Http2HeaderBlock block;
482 block[":status"] = "302";
483 block["location"] = kRedirectUrl;
484 block["set-cookie"] = "foo=bar";
485 return server_maker_.MakeResponseHeadersPacket(
486 packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
487 std::move(block), nullptr);
488 }
489
490 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectErrorReplyPacket(uint64_t packet_number,bool fin)491 ConstructServerConnectErrorReplyPacket(uint64_t packet_number, bool fin) {
492 spdy::Http2HeaderBlock block;
493 block[":status"] = "500";
494
495 return server_maker_.MakeResponseHeadersPacket(
496 packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
497 std::move(block), nullptr);
498 }
499
AssertConnectSucceeds()500 void AssertConnectSucceeds() {
501 TestCompletionCallback callback;
502 ASSERT_THAT(sock_->Connect(callback.callback()), IsError(ERR_IO_PENDING));
503 ASSERT_THAT(callback.WaitForResult(), IsOk());
504 }
505
AssertConnectFails(int result)506 void AssertConnectFails(int result) {
507 TestCompletionCallback callback;
508 ASSERT_THAT(sock_->Connect(callback.callback()), IsError(ERR_IO_PENDING));
509 ASSERT_EQ(result, callback.WaitForResult());
510 }
511
ResumeAndRun()512 void ResumeAndRun() {
513 // Run until the pause, if the provider isn't paused yet.
514 SequencedSocketData* data = mock_quic_data_.GetSequencedSocketData();
515 data->RunUntilPaused();
516 data->Resume();
517 base::RunLoop().RunUntilIdle();
518 }
519
AssertWriteReturns(const char * data,int len,int rv)520 void AssertWriteReturns(const char* data, int len, int rv) {
521 scoped_refptr<IOBufferWithSize> buf =
522 base::MakeRefCounted<IOBufferWithSize>(len);
523 memcpy(buf->data(), data, len);
524 EXPECT_EQ(rv,
525 sock_->Write(buf.get(), buf->size(), write_callback_.callback(),
526 TRAFFIC_ANNOTATION_FOR_TESTS));
527 }
528
AssertSyncWriteSucceeds(const char * data,int len)529 void AssertSyncWriteSucceeds(const char* data, int len) {
530 scoped_refptr<IOBufferWithSize> buf =
531 base::MakeRefCounted<IOBufferWithSize>(len);
532 memcpy(buf->data(), data, len);
533 EXPECT_EQ(len,
534 sock_->Write(buf.get(), buf->size(), CompletionOnceCallback(),
535 TRAFFIC_ANNOTATION_FOR_TESTS));
536 }
537
AssertSyncReadEquals(const char * data,int len)538 void AssertSyncReadEquals(const char* data, int len) {
539 scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
540 ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionOnceCallback()));
541 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
542 ASSERT_TRUE(sock_->IsConnected());
543 }
544
AssertAsyncReadEquals(const char * data,int len)545 void AssertAsyncReadEquals(const char* data, int len) {
546 scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
547 ASSERT_EQ(ERR_IO_PENDING,
548 sock_->Read(buf.get(), len, read_callback_.callback()));
549 EXPECT_TRUE(sock_->IsConnected());
550
551 ResumeAndRun();
552
553 EXPECT_EQ(len, read_callback_.WaitForResult());
554 EXPECT_TRUE(sock_->IsConnected());
555 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
556 }
557
AssertReadStarts(const char * data,int len)558 void AssertReadStarts(const char* data, int len) {
559 // Issue the read, which will be completed asynchronously.
560 read_buf_ = base::MakeRefCounted<IOBuffer>(len);
561 ASSERT_EQ(ERR_IO_PENDING,
562 sock_->Read(read_buf_.get(), len, read_callback_.callback()));
563 EXPECT_TRUE(sock_->IsConnected());
564 }
565
AssertReadReturns(const char * data,int len)566 void AssertReadReturns(const char* data, int len) {
567 EXPECT_TRUE(sock_->IsConnected());
568
569 // Now the read will return.
570 EXPECT_EQ(len, read_callback_.WaitForResult());
571 ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
572 }
573
ConstructDataHeader(size_t body_len)574 std::string ConstructDataHeader(size_t body_len) {
575 quiche::QuicheBuffer buffer = quic::HttpEncoder::SerializeDataFrameHeader(
576 body_len, quiche::SimpleBufferAllocator::Get());
577 return std::string(buffer.data(), buffer.size());
578 }
579
580 RecordingNetLogObserver net_log_observer_;
581 quic::test::QuicFlagSaver saver_;
582 const quic::ParsedQuicVersion version_;
583 const quic::QuicStreamId client_data_stream_id1_;
584
585 // order of destruction of these members matter
586 quic::MockClock clock_;
587 MockQuicData mock_quic_data_;
588 std::unique_ptr<QuicChromiumConnectionHelper> helper_;
589 std::unique_ptr<QuicChromiumClientSession> session_;
590 std::unique_ptr<QuicChromiumClientSession::Handle> session_handle_;
591 std::unique_ptr<QuicProxyClientSocket> sock_;
592 std::unique_ptr<TestProxyDelegate> proxy_delegate_;
593
594 raw_ptr<quic::test::MockSendAlgorithm> send_algorithm_;
595 scoped_refptr<TestTaskRunner> runner_;
596
597 std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_;
598 testing::StrictMock<quic::test::MockQuicConnectionVisitor> visitor_;
599 TransportSecurityState transport_security_state_;
600 SSLConfigServiceDefaults ssl_config_service_;
601 quic::QuicCryptoClientConfig crypto_config_;
602
603 const quic::QuicConnectionId connection_id_;
604 QuicTestPacketMaker client_maker_;
605 QuicTestPacketMaker server_maker_;
606 IPEndPoint peer_addr_;
607 quic::test::MockRandom random_generator_{0};
608 ProofVerifyDetailsChromium verify_details_;
609 MockCryptoClientStreamFactory crypto_client_stream_factory_;
610 quic::test::MockConnectionIdGenerator connection_id_generator_;
611
612 std::string user_agent_;
613 url::SchemeHostPort proxy_endpoint_;
614 url::SchemeHostPort destination_endpoint_;
615 HttpAuthCache http_auth_cache_;
616 std::unique_ptr<MockHostResolverBase> host_resolver_;
617 std::unique_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory_;
618
619 TestCompletionCallback read_callback_;
620 scoped_refptr<IOBuffer> read_buf_;
621
622 TestCompletionCallback write_callback_;
623
624 quic::test::NoopQpackStreamSenderDelegate noop_qpack_stream_sender_delegate_;
625 };
626
TEST_P(QuicProxyClientSocketTest,ConnectSendsCorrectRequest)627 TEST_P(QuicProxyClientSocketTest, ConnectSendsCorrectRequest) {
628 int packet_number = 1;
629 mock_quic_data_.AddWrite(SYNCHRONOUS,
630 ConstructSettingsPacket(packet_number++));
631 mock_quic_data_.AddWrite(SYNCHRONOUS,
632 ConstructConnectRequestPacket(packet_number++));
633 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
634 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
635 mock_quic_data_.AddWrite(
636 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
637 quic::QUIC_STREAM_CANCELLED, 1, 1));
638
639 Initialize();
640
641 ASSERT_FALSE(sock_->IsConnected());
642
643 AssertConnectSucceeds();
644
645 const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
646 ASSERT_TRUE(response != nullptr);
647 ASSERT_EQ(200, response->headers->response_code());
648
649 // Although the underlying HTTP/3 connection uses TLS and negotiates ALPN, the
650 // tunnel itself is a TCP connection to the origin and should not report these
651 // values.
652 net::SSLInfo ssl_info;
653 EXPECT_FALSE(sock_->GetSSLInfo(&ssl_info));
654 EXPECT_FALSE(sock_->WasAlpnNegotiated());
655 EXPECT_EQ(sock_->GetNegotiatedProtocol(), NextProto::kProtoUnknown);
656 }
657
TEST_P(QuicProxyClientSocketTest,ProxyDelegateExtraHeaders)658 TEST_P(QuicProxyClientSocketTest, ProxyDelegateExtraHeaders) {
659 proxy_delegate_ = std::make_unique<TestProxyDelegate>();
660 // TODO(crbug.com/1206799) Construct `ProxyServer` with plain
661 // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
662 ProxyServer proxy_server(ProxyServer::SCHEME_HTTPS,
663 HostPortPair::FromSchemeHostPort(proxy_endpoint_));
664
665 const char kResponseHeaderName[] = "foo";
666 const char kResponseHeaderValue[] = "testing";
667
668 int packet_number = 1;
669 mock_quic_data_.AddWrite(SYNCHRONOUS,
670 ConstructSettingsPacket(packet_number++));
671 mock_quic_data_.AddWrite(SYNCHRONOUS,
672 ConstructConnectRequestPacketWithExtraHeaders(
673 packet_number++,
674 // Order matters! Keep these alphabetical.
675 {{"foo", ProxyServerToProxyUri(proxy_server)},
676 {"user-agent", kUserAgent}}));
677 mock_quic_data_.AddRead(
678 ASYNC, ConstructServerConnectReplyPacketWithExtraHeaders(
679 1, !kFin, {{kResponseHeaderName, kResponseHeaderValue}}));
680 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
681 mock_quic_data_.AddWrite(
682 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
683 quic::QUIC_STREAM_CANCELLED, 1, 1));
684
685 Initialize();
686
687 ASSERT_FALSE(sock_->IsConnected());
688
689 AssertConnectSucceeds();
690
691 const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
692 ASSERT_TRUE(response != nullptr);
693 ASSERT_EQ(200, response->headers->response_code());
694 proxy_delegate_->VerifyOnTunnelHeadersReceived(
695 proxy_server, kResponseHeaderName, kResponseHeaderValue);
696 }
697
TEST_P(QuicProxyClientSocketTest,ConnectWithAuthRequested)698 TEST_P(QuicProxyClientSocketTest, ConnectWithAuthRequested) {
699 int packet_number = 1;
700 mock_quic_data_.AddWrite(SYNCHRONOUS,
701 ConstructSettingsPacket(packet_number++));
702 mock_quic_data_.AddWrite(SYNCHRONOUS,
703 ConstructConnectRequestPacket(packet_number++));
704 mock_quic_data_.AddRead(ASYNC,
705 ConstructServerConnectAuthReplyPacket(1, !kFin));
706 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
707 mock_quic_data_.AddWrite(
708 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
709 quic::QUIC_STREAM_CANCELLED, 1, 1));
710
711 Initialize();
712
713 AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
714
715 const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
716 ASSERT_TRUE(response != nullptr);
717 ASSERT_EQ(407, response->headers->response_code());
718 }
719
TEST_P(QuicProxyClientSocketTest,ConnectWithAuthCredentials)720 TEST_P(QuicProxyClientSocketTest, ConnectWithAuthCredentials) {
721 int packet_number = 1;
722 mock_quic_data_.AddWrite(SYNCHRONOUS,
723 ConstructSettingsPacket(packet_number++));
724 mock_quic_data_.AddWrite(SYNCHRONOUS,
725 ConstructConnectAuthRequestPacket(packet_number++));
726 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
727 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
728 mock_quic_data_.AddWrite(
729 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
730 quic::QUIC_STREAM_CANCELLED, 1, 1));
731
732 Initialize();
733
734 // Add auth to cache
735 const std::u16string kFoo(u"foo");
736 const std::u16string kBar(u"bar");
737 http_auth_cache_.Add(
738 url::SchemeHostPort(GURL(kProxyUrl)), HttpAuth::AUTH_PROXY, "MyRealm1",
739 HttpAuth::AUTH_SCHEME_BASIC, NetworkAnonymizationKey(),
740 "Basic realm=MyRealm1", AuthCredentials(kFoo, kBar), "/");
741
742 AssertConnectSucceeds();
743
744 const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
745 ASSERT_TRUE(response != nullptr);
746 ASSERT_EQ(200, response->headers->response_code());
747 }
748
749 // Tests that a redirect response from a CONNECT fails.
TEST_P(QuicProxyClientSocketTest,ConnectRedirects)750 TEST_P(QuicProxyClientSocketTest, ConnectRedirects) {
751 int packet_number = 1;
752 mock_quic_data_.AddWrite(SYNCHRONOUS,
753 ConstructSettingsPacket(packet_number++));
754 mock_quic_data_.AddWrite(SYNCHRONOUS,
755 ConstructConnectRequestPacket(packet_number++));
756 mock_quic_data_.AddRead(ASYNC,
757 ConstructServerConnectRedirectReplyPacket(1, !kFin));
758 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
759 mock_quic_data_.AddWrite(
760 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
761 quic::QUIC_STREAM_CANCELLED, 1, 1));
762
763 Initialize();
764
765 AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED);
766
767 const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
768 ASSERT_TRUE(response != nullptr);
769
770 const HttpResponseHeaders* headers = response->headers.get();
771 ASSERT_EQ(302, headers->response_code());
772 ASSERT_TRUE(headers->HasHeader("set-cookie"));
773
774 std::string location;
775 ASSERT_TRUE(headers->IsRedirect(&location));
776 ASSERT_EQ(location, kRedirectUrl);
777 }
778
TEST_P(QuicProxyClientSocketTest,ConnectFails)779 TEST_P(QuicProxyClientSocketTest, ConnectFails) {
780 int packet_number = 1;
781 mock_quic_data_.AddWrite(SYNCHRONOUS,
782 ConstructSettingsPacket(packet_number++));
783 mock_quic_data_.AddWrite(SYNCHRONOUS,
784 ConstructConnectRequestPacket(packet_number++));
785 mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
786
787 Initialize();
788
789 ASSERT_FALSE(sock_->IsConnected());
790
791 AssertConnectFails(ERR_QUIC_PROTOCOL_ERROR);
792
793 ASSERT_FALSE(sock_->IsConnected());
794 }
795
TEST_P(QuicProxyClientSocketTest,WasEverUsedReturnsCorrectValue)796 TEST_P(QuicProxyClientSocketTest, WasEverUsedReturnsCorrectValue) {
797 int packet_number = 1;
798 mock_quic_data_.AddWrite(SYNCHRONOUS,
799 ConstructSettingsPacket(packet_number++));
800 mock_quic_data_.AddWrite(SYNCHRONOUS,
801 ConstructConnectRequestPacket(packet_number++));
802 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
803 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
804 mock_quic_data_.AddWrite(
805 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
806 quic::QUIC_STREAM_CANCELLED, 1, 1));
807
808 Initialize();
809
810 EXPECT_TRUE(sock_->WasEverUsed()); // Used due to crypto handshake
811 AssertConnectSucceeds();
812 EXPECT_TRUE(sock_->WasEverUsed());
813 sock_->Disconnect();
814 EXPECT_TRUE(sock_->WasEverUsed());
815 }
816
TEST_P(QuicProxyClientSocketTest,GetPeerAddressReturnsCorrectValues)817 TEST_P(QuicProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) {
818 int packet_number = 1;
819 mock_quic_data_.AddWrite(SYNCHRONOUS,
820 ConstructSettingsPacket(packet_number++));
821 mock_quic_data_.AddWrite(SYNCHRONOUS,
822 ConstructConnectRequestPacket(packet_number++));
823 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
824 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
825 mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
826
827 Initialize();
828
829 IPEndPoint addr;
830 EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
831
832 AssertConnectSucceeds();
833 EXPECT_TRUE(sock_->IsConnected());
834 EXPECT_THAT(sock_->GetPeerAddress(&addr), IsOk());
835
836 ResumeAndRun();
837
838 EXPECT_FALSE(sock_->IsConnected());
839 EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
840
841 sock_->Disconnect();
842
843 EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
844 }
845
TEST_P(QuicProxyClientSocketTest,IsConnectedAndIdle)846 TEST_P(QuicProxyClientSocketTest, IsConnectedAndIdle) {
847 int packet_number = 1;
848 mock_quic_data_.AddWrite(SYNCHRONOUS,
849 ConstructSettingsPacket(packet_number++));
850 mock_quic_data_.AddWrite(SYNCHRONOUS,
851 ConstructConnectRequestPacket(packet_number++));
852 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
853 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
854
855 std::string header = ConstructDataHeader(kLen1);
856 mock_quic_data_.AddRead(
857 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
858 mock_quic_data_.AddWrite(SYNCHRONOUS,
859 ConstructAckPacket(packet_number++, 2, 1));
860 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
861 mock_quic_data_.AddWrite(
862 SYNCHRONOUS,
863 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
864
865 Initialize();
866
867 EXPECT_FALSE(sock_->IsConnectedAndIdle());
868
869 AssertConnectSucceeds();
870
871 EXPECT_TRUE(sock_->IsConnectedAndIdle());
872
873 // The next read is consumed and buffered.
874 ResumeAndRun();
875
876 EXPECT_FALSE(sock_->IsConnectedAndIdle());
877
878 AssertSyncReadEquals(kMsg1, kLen1);
879
880 EXPECT_TRUE(sock_->IsConnectedAndIdle());
881 }
882
TEST_P(QuicProxyClientSocketTest,GetTotalReceivedBytes)883 TEST_P(QuicProxyClientSocketTest, GetTotalReceivedBytes) {
884 int packet_number = 1;
885 mock_quic_data_.AddWrite(SYNCHRONOUS,
886 ConstructSettingsPacket(packet_number++));
887 size_t header_length;
888 mock_quic_data_.AddWrite(SYNCHRONOUS,
889 ConstructConnectRequestPacket(packet_number++));
890 mock_quic_data_.AddRead(
891 ASYNC, ConstructServerConnectReplyPacket(1, !kFin, &header_length));
892 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
893
894 std::string data_header = ConstructDataHeader(kLen333);
895 mock_quic_data_.AddRead(ASYNC,
896 ConstructServerDataPacket(
897 2, data_header + std::string(kMsg333, kLen333)));
898 mock_quic_data_.AddWrite(SYNCHRONOUS,
899 ConstructAckPacket(packet_number++, 2, 1));
900 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
901 mock_quic_data_.AddWrite(
902 SYNCHRONOUS,
903 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
904
905 Initialize();
906
907 EXPECT_EQ(0, sock_->GetTotalReceivedBytes());
908
909 AssertConnectSucceeds();
910
911 EXPECT_EQ((int64_t)(header_length), sock_->GetTotalReceivedBytes());
912
913 // The next read is consumed and buffered.
914 ResumeAndRun();
915
916 EXPECT_EQ((int64_t)(header_length + data_header.length()),
917 sock_->GetTotalReceivedBytes());
918
919 // The payload from the single large data frame will be read across
920 // two different reads.
921 AssertSyncReadEquals(kMsg33, kLen33);
922
923 EXPECT_EQ((int64_t)(header_length + data_header.length() + kLen33),
924 sock_->GetTotalReceivedBytes());
925
926 AssertSyncReadEquals(kMsg3, kLen3);
927
928 EXPECT_EQ((int64_t)(header_length + kLen333 + data_header.length()),
929 sock_->GetTotalReceivedBytes());
930 }
931
TEST_P(QuicProxyClientSocketTest,SetStreamPriority)932 TEST_P(QuicProxyClientSocketTest, SetStreamPriority) {
933 int packet_number = 1;
934 mock_quic_data_.AddWrite(SYNCHRONOUS,
935 ConstructSettingsPacket(packet_number++));
936 // Despite setting the priority to HIGHEST, the requests initial priority of
937 // LOWEST is used.
938 mock_quic_data_.AddWrite(
939 SYNCHRONOUS, ConstructConnectRequestPacket(packet_number++, LOWEST));
940 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
941 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
942 mock_quic_data_.AddWrite(
943 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
944 quic::QUIC_STREAM_CANCELLED, 1, 1));
945
946 Initialize();
947
948 sock_->SetStreamPriority(HIGHEST);
949 AssertConnectSucceeds();
950 }
951
TEST_P(QuicProxyClientSocketTest,WriteSendsDataInDataFrame)952 TEST_P(QuicProxyClientSocketTest, WriteSendsDataInDataFrame) {
953 int packet_number = 1;
954 mock_quic_data_.AddWrite(SYNCHRONOUS,
955 ConstructSettingsPacket(packet_number++));
956 mock_quic_data_.AddWrite(SYNCHRONOUS,
957 ConstructConnectRequestPacket(packet_number++));
958 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
959 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
960 std::string header = ConstructDataHeader(kLen1);
961 mock_quic_data_.AddWrite(
962 SYNCHRONOUS,
963 ConstructAckAndDataPacket(packet_number++, 1, 1,
964 {header + std::string(kMsg1, kLen1)}));
965 std::string header2 = ConstructDataHeader(kLen2);
966 mock_quic_data_.AddWrite(
967 SYNCHRONOUS, ConstructDataPacket(packet_number++,
968 {header2 + std::string(kMsg2, kLen2)}));
969 mock_quic_data_.AddWrite(
970 SYNCHRONOUS,
971 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
972
973 Initialize();
974
975 AssertConnectSucceeds();
976
977 AssertSyncWriteSucceeds(kMsg1, kLen1);
978 AssertSyncWriteSucceeds(kMsg2, kLen2);
979 }
980
TEST_P(QuicProxyClientSocketTest,WriteSplitsLargeDataIntoMultiplePackets)981 TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
982 int write_packet_index = 1;
983 mock_quic_data_.AddWrite(SYNCHRONOUS,
984 ConstructSettingsPacket(write_packet_index++));
985 mock_quic_data_.AddWrite(SYNCHRONOUS,
986 ConstructConnectRequestPacket(write_packet_index++));
987 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
988 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
989 std::string header = ConstructDataHeader(kLen1);
990 mock_quic_data_.AddWrite(
991 SYNCHRONOUS,
992 ConstructAckAndDataPacket(write_packet_index++, 1, 1,
993 {header + std::string(kMsg1, kLen1)}));
994
995 // Expect |kNumDataPackets| data packets, each containing the max possible
996 // amount of data.
997 int numDataPackets = 3;
998 std::string data(numDataPackets * quic::kDefaultMaxPacketSize, 'x');
999 quic::QuicStreamOffset offset = kLen1 + header.length();
1000
1001 numDataPackets++;
1002 size_t total_data_length = 0;
1003 for (int i = 0; i < numDataPackets; ++i) {
1004 size_t max_packet_data_length = GetStreamFrameDataLengthFromPacketLength(
1005 quic::kDefaultMaxPacketSize, version_, !kIncludeVersion,
1006 !kIncludeDiversificationNonce, k8ByteConnectionId,
1007 quic::PACKET_1BYTE_PACKET_NUMBER, offset);
1008 if (i == 0) {
1009 // 3661 is the data frame length from packet length.
1010 std::string header2 = ConstructDataHeader(3661);
1011 mock_quic_data_.AddWrite(
1012 SYNCHRONOUS,
1013 ConstructDataPacket(
1014 write_packet_index++,
1015 {header2 +
1016 std::string(data.c_str(), max_packet_data_length - 7)}));
1017 offset += max_packet_data_length - header2.length() - 1;
1018 } else if (i == numDataPackets - 1) {
1019 mock_quic_data_.AddWrite(
1020 SYNCHRONOUS, ConstructDataPacket(write_packet_index++,
1021 std::string(data.c_str(), 7)));
1022 offset += 7;
1023 } else {
1024 mock_quic_data_.AddWrite(
1025 SYNCHRONOUS, ConstructDataPacket(
1026 write_packet_index++,
1027 std::string(data.c_str(), max_packet_data_length)));
1028 offset += max_packet_data_length;
1029 }
1030 if (i != 3) {
1031 total_data_length += max_packet_data_length;
1032 }
1033 }
1034
1035 mock_quic_data_.AddWrite(
1036 SYNCHRONOUS,
1037 ConstructRstPacket(write_packet_index++, quic::QUIC_STREAM_CANCELLED));
1038
1039 Initialize();
1040
1041 AssertConnectSucceeds();
1042
1043 // Make a small write. An ACK and STOP_WAITING will be bundled. This prevents
1044 // ACK and STOP_WAITING from being bundled with the subsequent large write.
1045 // This allows the test code for computing the size of data sent in each
1046 // packet to not become too complicated.
1047 AssertSyncWriteSucceeds(kMsg1, kLen1);
1048
1049 // Make large write that should be split up
1050 AssertSyncWriteSucceeds(data.c_str(), total_data_length);
1051 }
1052
1053 // ----------- Read
1054
TEST_P(QuicProxyClientSocketTest,ReadReadsDataInDataFrame)1055 TEST_P(QuicProxyClientSocketTest, ReadReadsDataInDataFrame) {
1056 int packet_number = 1;
1057 mock_quic_data_.AddWrite(SYNCHRONOUS,
1058 ConstructSettingsPacket(packet_number++));
1059 mock_quic_data_.AddWrite(SYNCHRONOUS,
1060 ConstructConnectRequestPacket(packet_number++));
1061 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1062 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1063
1064 std::string header = ConstructDataHeader(kLen1);
1065 mock_quic_data_.AddRead(
1066 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1067 mock_quic_data_.AddWrite(SYNCHRONOUS,
1068 ConstructAckPacket(packet_number++, 2, 1));
1069 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1070 mock_quic_data_.AddWrite(
1071 SYNCHRONOUS,
1072 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
1073
1074 Initialize();
1075
1076 AssertConnectSucceeds();
1077
1078 ResumeAndRun();
1079 AssertSyncReadEquals(kMsg1, kLen1);
1080 }
1081
TEST_P(QuicProxyClientSocketTest,ReadDataFromBufferedFrames)1082 TEST_P(QuicProxyClientSocketTest, ReadDataFromBufferedFrames) {
1083 int packet_number = 1;
1084 mock_quic_data_.AddWrite(SYNCHRONOUS,
1085 ConstructSettingsPacket(packet_number++));
1086 mock_quic_data_.AddWrite(SYNCHRONOUS,
1087 ConstructConnectRequestPacket(packet_number++));
1088 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1089 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1090
1091 std::string header = ConstructDataHeader(kLen1);
1092 mock_quic_data_.AddRead(
1093 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1094 mock_quic_data_.AddWrite(SYNCHRONOUS,
1095 ConstructAckPacket(packet_number++, 2, 1));
1096 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1097
1098 std::string header2 = ConstructDataHeader(kLen2);
1099 mock_quic_data_.AddRead(
1100 ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
1101 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1102
1103 mock_quic_data_.AddWrite(
1104 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1105 quic::QUIC_STREAM_CANCELLED, 3, 3));
1106
1107 Initialize();
1108
1109 AssertConnectSucceeds();
1110
1111 ResumeAndRun();
1112 AssertSyncReadEquals(kMsg1, kLen1);
1113
1114 ResumeAndRun();
1115 AssertSyncReadEquals(kMsg2, kLen2);
1116 }
1117
TEST_P(QuicProxyClientSocketTest,ReadDataMultipleBufferedFrames)1118 TEST_P(QuicProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
1119 int packet_number = 1;
1120 mock_quic_data_.AddWrite(SYNCHRONOUS,
1121 ConstructSettingsPacket(packet_number++));
1122 mock_quic_data_.AddWrite(SYNCHRONOUS,
1123 ConstructConnectRequestPacket(packet_number++));
1124 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1125 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1126
1127 std::string header = ConstructDataHeader(kLen1);
1128 mock_quic_data_.AddRead(
1129 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1130 mock_quic_data_.AddWrite(SYNCHRONOUS,
1131 ConstructAckPacket(packet_number++, 2, 1));
1132 std::string header2 = ConstructDataHeader(kLen2);
1133 mock_quic_data_.AddRead(
1134 ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
1135 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1136
1137 mock_quic_data_.AddWrite(
1138 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1139 quic::QUIC_STREAM_CANCELLED, 3, 3));
1140
1141 Initialize();
1142
1143 AssertConnectSucceeds();
1144
1145 // The next two reads are consumed and buffered.
1146 ResumeAndRun();
1147
1148 AssertSyncReadEquals(kMsg1, kLen1);
1149 AssertSyncReadEquals(kMsg2, kLen2);
1150 }
1151
TEST_P(QuicProxyClientSocketTest,LargeReadWillMergeDataFromDifferentFrames)1152 TEST_P(QuicProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) {
1153 int packet_number = 1;
1154 mock_quic_data_.AddWrite(SYNCHRONOUS,
1155 ConstructSettingsPacket(packet_number++));
1156 mock_quic_data_.AddWrite(SYNCHRONOUS,
1157 ConstructConnectRequestPacket(packet_number++));
1158 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1159 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1160
1161 std::string header = ConstructDataHeader(kLen3);
1162 mock_quic_data_.AddRead(
1163 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg3, kLen3)));
1164 mock_quic_data_.AddWrite(SYNCHRONOUS,
1165 ConstructAckPacket(packet_number++, 2, 1));
1166 std::string header2 = ConstructDataHeader(kLen3);
1167 mock_quic_data_.AddRead(
1168 ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
1169 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1170
1171 mock_quic_data_.AddWrite(
1172 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1173 quic::QUIC_STREAM_CANCELLED, 3, 3));
1174
1175 Initialize();
1176
1177 AssertConnectSucceeds();
1178
1179 // The next two reads are consumed and buffered.
1180 ResumeAndRun();
1181 // The payload from two data frames, each with kMsg3 will be combined
1182 // together into a single read().
1183 AssertSyncReadEquals(kMsg33, kLen33);
1184 }
1185
TEST_P(QuicProxyClientSocketTest,MultipleShortReadsThenMoreRead)1186 TEST_P(QuicProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
1187 int packet_number = 1;
1188 mock_quic_data_.AddWrite(SYNCHRONOUS,
1189 ConstructSettingsPacket(packet_number++));
1190 mock_quic_data_.AddWrite(SYNCHRONOUS,
1191 ConstructConnectRequestPacket(packet_number++));
1192 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1193 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1194
1195 std::string header = ConstructDataHeader(kLen1);
1196 mock_quic_data_.AddRead(
1197 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1198 mock_quic_data_.AddWrite(SYNCHRONOUS,
1199 ConstructAckPacket(packet_number++, 2, 1));
1200
1201 std::string header2 = ConstructDataHeader(kLen3);
1202 mock_quic_data_.AddRead(
1203 ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
1204 mock_quic_data_.AddRead(
1205 ASYNC, ConstructServerDataPacket(4, header2 + std::string(kMsg3, kLen3)));
1206 mock_quic_data_.AddWrite(SYNCHRONOUS,
1207 ConstructAckPacket(packet_number++, 4, 3));
1208
1209 std::string header3 = ConstructDataHeader(kLen2);
1210 mock_quic_data_.AddRead(
1211 ASYNC, ConstructServerDataPacket(5, header3 + std::string(kMsg2, kLen2)));
1212 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1213
1214 mock_quic_data_.AddWrite(
1215 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1216 quic::QUIC_STREAM_CANCELLED, 5, 5));
1217
1218 Initialize();
1219
1220 AssertConnectSucceeds();
1221
1222 // The next 4 reads are consumed and buffered.
1223 ResumeAndRun();
1224
1225 AssertSyncReadEquals(kMsg1, kLen1);
1226 // The payload from two data frames, each with kMsg3 will be combined
1227 // together into a single read().
1228 AssertSyncReadEquals(kMsg33, kLen33);
1229 AssertSyncReadEquals(kMsg2, kLen2);
1230 }
1231
TEST_P(QuicProxyClientSocketTest,ReadWillSplitDataFromLargeFrame)1232 TEST_P(QuicProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
1233 int packet_number = 1;
1234 mock_quic_data_.AddWrite(SYNCHRONOUS,
1235 ConstructSettingsPacket(packet_number++));
1236 mock_quic_data_.AddWrite(SYNCHRONOUS,
1237 ConstructConnectRequestPacket(packet_number++));
1238 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1239 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1240
1241 std::string header = ConstructDataHeader(kLen1);
1242 mock_quic_data_.AddRead(
1243 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1244 mock_quic_data_.AddWrite(SYNCHRONOUS,
1245 ConstructAckPacket(packet_number++, 2, 1));
1246 std::string header2 = ConstructDataHeader(kLen33);
1247 mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
1248 3, header2 + std::string(kMsg33, kLen33)));
1249 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1250
1251 mock_quic_data_.AddWrite(
1252 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1253 quic::QUIC_STREAM_CANCELLED, 3, 3));
1254
1255 Initialize();
1256
1257 AssertConnectSucceeds();
1258
1259 // The next 2 reads are consumed and buffered.
1260 ResumeAndRun();
1261
1262 AssertSyncReadEquals(kMsg1, kLen1);
1263 // The payload from the single large data frame will be read across
1264 // two different reads.
1265 AssertSyncReadEquals(kMsg3, kLen3);
1266 AssertSyncReadEquals(kMsg3, kLen3);
1267 }
1268
TEST_P(QuicProxyClientSocketTest,MultipleReadsFromSameLargeFrame)1269 TEST_P(QuicProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
1270 int packet_number = 1;
1271 mock_quic_data_.AddWrite(SYNCHRONOUS,
1272 ConstructSettingsPacket(packet_number++));
1273 mock_quic_data_.AddWrite(SYNCHRONOUS,
1274 ConstructConnectRequestPacket(packet_number++));
1275 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1276 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1277
1278 std::string header = ConstructDataHeader(kLen333);
1279 mock_quic_data_.AddRead(
1280 ASYNC,
1281 ConstructServerDataPacket(2, header + std::string(kMsg333, kLen333)));
1282 mock_quic_data_.AddWrite(SYNCHRONOUS,
1283 ConstructAckPacket(packet_number++, 2, 1));
1284 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1285
1286 mock_quic_data_.AddWrite(
1287 SYNCHRONOUS,
1288 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
1289
1290 Initialize();
1291
1292 AssertConnectSucceeds();
1293
1294 // The next read is consumed and buffered.
1295 ResumeAndRun();
1296
1297 // The payload from the single large data frame will be read across
1298 // two different reads.
1299 AssertSyncReadEquals(kMsg33, kLen33);
1300
1301 // Now attempt to do a read of more data than remains buffered
1302 scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(kLen33);
1303 ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, CompletionOnceCallback()));
1304 ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3));
1305 ASSERT_TRUE(sock_->IsConnected());
1306 }
1307
TEST_P(QuicProxyClientSocketTest,ReadAuthResponseBody)1308 TEST_P(QuicProxyClientSocketTest, ReadAuthResponseBody) {
1309 int packet_number = 1;
1310 mock_quic_data_.AddWrite(SYNCHRONOUS,
1311 ConstructSettingsPacket(packet_number++));
1312 mock_quic_data_.AddWrite(SYNCHRONOUS,
1313 ConstructConnectRequestPacket(packet_number++));
1314 mock_quic_data_.AddRead(ASYNC,
1315 ConstructServerConnectAuthReplyPacket(1, !kFin));
1316 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1317
1318 std::string header = ConstructDataHeader(kLen1);
1319 mock_quic_data_.AddRead(
1320 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1321 mock_quic_data_.AddWrite(SYNCHRONOUS,
1322 ConstructAckPacket(packet_number++, 2, 1));
1323 std::string header2 = ConstructDataHeader(kLen2);
1324 mock_quic_data_.AddRead(
1325 ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
1326 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1327
1328 mock_quic_data_.AddWrite(
1329 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1330 quic::QUIC_STREAM_CANCELLED, 3, 3));
1331
1332 Initialize();
1333
1334 AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
1335
1336 // The next two reads are consumed and buffered.
1337 ResumeAndRun();
1338
1339 AssertSyncReadEquals(kMsg1, kLen1);
1340 AssertSyncReadEquals(kMsg2, kLen2);
1341 }
1342
TEST_P(QuicProxyClientSocketTest,ReadErrorResponseBody)1343 TEST_P(QuicProxyClientSocketTest, ReadErrorResponseBody) {
1344 int packet_number = 1;
1345 mock_quic_data_.AddWrite(SYNCHRONOUS,
1346 ConstructSettingsPacket(packet_number++));
1347 mock_quic_data_.AddWrite(SYNCHRONOUS,
1348 ConstructConnectRequestPacket(packet_number++));
1349 mock_quic_data_.AddRead(ASYNC,
1350 ConstructServerConnectErrorReplyPacket(1, !kFin));
1351 std::string header = ConstructDataHeader(kLen1);
1352 mock_quic_data_.AddRead(
1353 SYNCHRONOUS,
1354 ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1355 mock_quic_data_.AddWrite(SYNCHRONOUS,
1356 ConstructAckPacket(packet_number++, 2, 1));
1357 std::string header2 = ConstructDataHeader(kLen2);
1358 mock_quic_data_.AddRead(
1359 SYNCHRONOUS,
1360 ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
1361 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1362
1363 mock_quic_data_.AddWrite(
1364 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1365 quic::QUIC_STREAM_CANCELLED, 3, 3));
1366 Initialize();
1367
1368 AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED);
1369 }
1370
1371 // ----------- Reads and Writes
1372
TEST_P(QuicProxyClientSocketTest,AsyncReadAroundWrite)1373 TEST_P(QuicProxyClientSocketTest, AsyncReadAroundWrite) {
1374 int write_packet_index = 1;
1375 mock_quic_data_.AddWrite(SYNCHRONOUS,
1376 ConstructSettingsPacket(write_packet_index++));
1377 mock_quic_data_.AddWrite(SYNCHRONOUS,
1378 ConstructConnectRequestPacket(write_packet_index++));
1379 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1380 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1381
1382 std::string header = ConstructDataHeader(kLen1);
1383 mock_quic_data_.AddRead(
1384 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1385 mock_quic_data_.AddWrite(SYNCHRONOUS,
1386 ConstructAckPacket(write_packet_index++, 2, 1));
1387
1388 std::string header2 = ConstructDataHeader(kLen2);
1389 mock_quic_data_.AddWrite(
1390 SYNCHRONOUS, ConstructDataPacket(write_packet_index++,
1391 {header2 + std::string(kMsg2, kLen2)}));
1392
1393 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1394
1395 std::string header3 = ConstructDataHeader(kLen3);
1396 mock_quic_data_.AddRead(
1397 ASYNC, ConstructServerDataPacket(3, header3 + std::string(kMsg3, kLen3)));
1398 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1399
1400 mock_quic_data_.AddWrite(
1401 SYNCHRONOUS, ConstructAckAndRstPacket(write_packet_index++,
1402 quic::QUIC_STREAM_CANCELLED, 3, 3));
1403
1404 Initialize();
1405
1406 AssertConnectSucceeds();
1407
1408 ResumeAndRun();
1409
1410 AssertSyncReadEquals(kMsg1, kLen1);
1411
1412 AssertReadStarts(kMsg3, kLen3);
1413 // Read should block until after the write succeeds.
1414
1415 AssertSyncWriteSucceeds(kMsg2, kLen2);
1416
1417 ASSERT_FALSE(read_callback_.have_result());
1418 ResumeAndRun();
1419
1420 // Now the read will return.
1421 AssertReadReturns(kMsg3, kLen3);
1422 }
1423
TEST_P(QuicProxyClientSocketTest,AsyncWriteAroundReads)1424 TEST_P(QuicProxyClientSocketTest, AsyncWriteAroundReads) {
1425 int packet_number = 1;
1426 mock_quic_data_.AddWrite(SYNCHRONOUS,
1427 ConstructSettingsPacket(packet_number++));
1428 mock_quic_data_.AddWrite(SYNCHRONOUS,
1429 ConstructConnectRequestPacket(packet_number++));
1430 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1431 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1432
1433 std::string header = ConstructDataHeader(kLen1);
1434 mock_quic_data_.AddRead(
1435 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1436 mock_quic_data_.AddWrite(SYNCHRONOUS,
1437 ConstructAckPacket(packet_number++, 2, 1));
1438 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1439
1440 std::string header2 = ConstructDataHeader(kLen3);
1441 mock_quic_data_.AddRead(
1442 ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
1443 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1444
1445 mock_quic_data_.AddWrite(ASYNC, ERR_IO_PENDING); // Pause
1446
1447 std::string header3 = ConstructDataHeader(kLen2);
1448 mock_quic_data_.AddWrite(
1449 ASYNC, ConstructDataPacket(packet_number++,
1450 {header3 + std::string(kMsg2, kLen2)}));
1451 mock_quic_data_.AddWrite(
1452 ASYNC, ConstructAckAndDataPacket(packet_number++, 3, 3,
1453 header3 + std::string(kMsg2, kLen2)));
1454
1455 mock_quic_data_.AddWrite(
1456 SYNCHRONOUS,
1457 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
1458
1459 Initialize();
1460
1461 AssertConnectSucceeds();
1462
1463 ResumeAndRun();
1464 AssertSyncReadEquals(kMsg1, kLen1);
1465
1466 // Write should block until the next read completes.
1467 // QuicChromiumClientStream::Handle::WriteStreamData() will only be
1468 // asynchronous starting with the second time it's called while the UDP socket
1469 // is write-blocked. Therefore, at least two writes need to be called on
1470 // |sock_| to get an asynchronous one.
1471 AssertWriteReturns(kMsg2, kLen2, kLen2);
1472 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
1473
1474 AssertAsyncReadEquals(kMsg3, kLen3);
1475
1476 ASSERT_FALSE(write_callback_.have_result());
1477
1478 // Now the write will complete
1479 ResumeAndRun();
1480 EXPECT_EQ(kLen2, write_callback_.WaitForResult());
1481 }
1482
1483 // ----------- Reading/Writing on Closed socket
1484
1485 // Reading from an already closed socket should return 0
TEST_P(QuicProxyClientSocketTest,ReadOnClosedSocketReturnsZero)1486 TEST_P(QuicProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
1487 int packet_number = 1;
1488 mock_quic_data_.AddWrite(SYNCHRONOUS,
1489 ConstructSettingsPacket(packet_number++));
1490 mock_quic_data_.AddWrite(SYNCHRONOUS,
1491 ConstructConnectRequestPacket(packet_number++));
1492 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1493 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1494 mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1495
1496 Initialize();
1497
1498 AssertConnectSucceeds();
1499
1500 ResumeAndRun();
1501
1502 ASSERT_FALSE(sock_->IsConnected());
1503 ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
1504 ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
1505 ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
1506 ASSERT_FALSE(sock_->IsConnectedAndIdle());
1507 }
1508
1509 // Read pending when socket is closed should return 0
TEST_P(QuicProxyClientSocketTest,PendingReadOnCloseReturnsZero)1510 TEST_P(QuicProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
1511 int packet_number = 1;
1512 mock_quic_data_.AddWrite(SYNCHRONOUS,
1513 ConstructSettingsPacket(packet_number++));
1514 mock_quic_data_.AddWrite(SYNCHRONOUS,
1515 ConstructConnectRequestPacket(packet_number++));
1516 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1517 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1518 mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1519
1520 Initialize();
1521
1522 AssertConnectSucceeds();
1523
1524 AssertReadStarts(kMsg1, kLen1);
1525
1526 ResumeAndRun();
1527
1528 ASSERT_EQ(0, read_callback_.WaitForResult());
1529 }
1530
1531 // Reading from a disconnected socket is an error
TEST_P(QuicProxyClientSocketTest,ReadOnDisconnectSocketReturnsNotConnected)1532 TEST_P(QuicProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) {
1533 int packet_number = 1;
1534 mock_quic_data_.AddWrite(SYNCHRONOUS,
1535 ConstructSettingsPacket(packet_number++));
1536 mock_quic_data_.AddWrite(SYNCHRONOUS,
1537 ConstructConnectRequestPacket(packet_number++));
1538 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1539 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1540 mock_quic_data_.AddWrite(
1541 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1542 quic::QUIC_STREAM_CANCELLED, 1, 1));
1543
1544 Initialize();
1545
1546 AssertConnectSucceeds();
1547
1548 sock_->Disconnect();
1549
1550 ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
1551 sock_->Read(nullptr, 1, CompletionOnceCallback()));
1552 }
1553
1554 // Reading data after receiving FIN should return buffered data received before
1555 // FIN, then 0.
TEST_P(QuicProxyClientSocketTest,ReadAfterFinReceivedReturnsBufferedData)1556 TEST_P(QuicProxyClientSocketTest, ReadAfterFinReceivedReturnsBufferedData) {
1557 int packet_number = 1;
1558 mock_quic_data_.AddWrite(SYNCHRONOUS,
1559 ConstructSettingsPacket(packet_number++));
1560 mock_quic_data_.AddWrite(SYNCHRONOUS,
1561 ConstructConnectRequestPacket(packet_number++));
1562 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1563 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1564
1565 std::string header = ConstructDataHeader(kLen1);
1566 mock_quic_data_.AddRead(ASYNC, ConstructServerDataFinPacket(
1567 2, header + std::string(kMsg1, kLen1)));
1568 mock_quic_data_.AddWrite(SYNCHRONOUS,
1569 ConstructAckPacket(packet_number++, 2, 1));
1570 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1571 mock_quic_data_.AddWrite(
1572 SYNCHRONOUS,
1573 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
1574
1575 Initialize();
1576
1577 AssertConnectSucceeds();
1578
1579 ResumeAndRun();
1580
1581 AssertSyncReadEquals(kMsg1, kLen1);
1582 ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
1583 ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
1584
1585 sock_->Disconnect();
1586 ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
1587 sock_->Read(nullptr, 1, CompletionOnceCallback()));
1588 }
1589
1590 // Calling Write() on a closed socket is an error.
TEST_P(QuicProxyClientSocketTest,WriteOnClosedStream)1591 TEST_P(QuicProxyClientSocketTest, WriteOnClosedStream) {
1592 int packet_number = 1;
1593 mock_quic_data_.AddWrite(SYNCHRONOUS,
1594 ConstructSettingsPacket(packet_number++));
1595 mock_quic_data_.AddWrite(SYNCHRONOUS,
1596 ConstructConnectRequestPacket(packet_number++));
1597 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1598 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1599 mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1600
1601 Initialize();
1602
1603 AssertConnectSucceeds();
1604
1605 ResumeAndRun();
1606
1607 AssertWriteReturns(kMsg1, kLen1, ERR_QUIC_PROTOCOL_ERROR);
1608 }
1609
1610 // Calling Write() on a disconnected socket is an error.
TEST_P(QuicProxyClientSocketTest,WriteOnDisconnectedSocket)1611 TEST_P(QuicProxyClientSocketTest, WriteOnDisconnectedSocket) {
1612 int packet_number = 1;
1613 mock_quic_data_.AddWrite(SYNCHRONOUS,
1614 ConstructSettingsPacket(packet_number++));
1615 mock_quic_data_.AddWrite(SYNCHRONOUS,
1616 ConstructConnectRequestPacket(packet_number++));
1617 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1618 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1619 mock_quic_data_.AddWrite(
1620 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1621 quic::QUIC_STREAM_CANCELLED, 1, 1));
1622
1623 Initialize();
1624
1625 AssertConnectSucceeds();
1626
1627 sock_->Disconnect();
1628
1629 AssertWriteReturns(kMsg1, kLen1, ERR_SOCKET_NOT_CONNECTED);
1630 }
1631
1632 // If the socket is closed with a pending Write(), the callback should be called
1633 // with the same error the session was closed with.
TEST_P(QuicProxyClientSocketTest,WritePendingOnClose)1634 TEST_P(QuicProxyClientSocketTest, WritePendingOnClose) {
1635 int packet_number = 1;
1636 mock_quic_data_.AddWrite(SYNCHRONOUS,
1637 ConstructSettingsPacket(packet_number++));
1638 mock_quic_data_.AddWrite(SYNCHRONOUS,
1639 ConstructConnectRequestPacket(packet_number++));
1640 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1641 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1642 mock_quic_data_.AddWrite(SYNCHRONOUS, ERR_IO_PENDING);
1643
1644 Initialize();
1645
1646 AssertConnectSucceeds();
1647
1648 // QuicChromiumClientStream::Handle::WriteStreamData() will only be
1649 // asynchronous starting with the second time it's called while the UDP socket
1650 // is write-blocked. Therefore, at least two writes need to be called on
1651 // |sock_| to get an asynchronous one.
1652 AssertWriteReturns(kMsg1, kLen1, kLen1);
1653
1654 // This second write will be async. This is the pending write that's being
1655 // tested.
1656 AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
1657
1658 // Make sure the write actually starts.
1659 base::RunLoop().RunUntilIdle();
1660
1661 session_->CloseSessionOnError(ERR_CONNECTION_CLOSED,
1662 quic::QUIC_INTERNAL_ERROR,
1663 quic::ConnectionCloseBehavior::SILENT_CLOSE);
1664
1665 EXPECT_THAT(write_callback_.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
1666 }
1667
TEST_P(QuicProxyClientSocketTest,DisconnectWithWritePending)1668 TEST_P(QuicProxyClientSocketTest, DisconnectWithWritePending) {
1669 int packet_number = 1;
1670 mock_quic_data_.AddWrite(SYNCHRONOUS,
1671 ConstructSettingsPacket(packet_number++));
1672 mock_quic_data_.AddWrite(SYNCHRONOUS,
1673 ConstructConnectRequestPacket(packet_number++));
1674 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1675 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1676 mock_quic_data_.AddWrite(SYNCHRONOUS, ERR_IO_PENDING);
1677
1678 Initialize();
1679
1680 AssertConnectSucceeds();
1681
1682 // QuicChromiumClientStream::Handle::WriteStreamData() will only be
1683 // asynchronous starting with the second time it's called while the UDP socket
1684 // is write-blocked. Therefore, at least two writes need to be called on
1685 // |sock_| to get an asynchronous one.
1686 AssertWriteReturns(kMsg1, kLen1, kLen1);
1687
1688 // This second write will be async. This is the pending write that's being
1689 // tested.
1690 AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
1691
1692 // Make sure the write actually starts.
1693 base::RunLoop().RunUntilIdle();
1694
1695 sock_->Disconnect();
1696 EXPECT_FALSE(sock_->IsConnected());
1697
1698 base::RunLoop().RunUntilIdle();
1699
1700 EXPECT_FALSE(sock_->IsConnected());
1701 EXPECT_FALSE(write_callback_.have_result());
1702 }
1703
1704 // If the socket is Disconnected with a pending Read(), the callback
1705 // should not be called.
TEST_P(QuicProxyClientSocketTest,DisconnectWithReadPending)1706 TEST_P(QuicProxyClientSocketTest, DisconnectWithReadPending) {
1707 int packet_number = 1;
1708 mock_quic_data_.AddWrite(SYNCHRONOUS,
1709 ConstructSettingsPacket(packet_number++));
1710 mock_quic_data_.AddWrite(SYNCHRONOUS,
1711 ConstructConnectRequestPacket(packet_number++));
1712 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1713 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1714 mock_quic_data_.AddWrite(
1715 SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
1716 quic::QUIC_STREAM_CANCELLED, 1, 1));
1717
1718 Initialize();
1719
1720 AssertConnectSucceeds();
1721
1722 EXPECT_TRUE(sock_->IsConnected());
1723
1724 AssertReadStarts(kMsg1, kLen1);
1725
1726 sock_->Disconnect();
1727 EXPECT_FALSE(sock_->IsConnected());
1728
1729 base::RunLoop().RunUntilIdle();
1730
1731 EXPECT_FALSE(sock_->IsConnected());
1732 EXPECT_FALSE(read_callback_.have_result());
1733 }
1734
1735 // If the socket is Reset when both a read and write are pending,
1736 // both should be called back.
TEST_P(QuicProxyClientSocketTest,RstWithReadAndWritePending)1737 TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePending) {
1738 int packet_number = 1;
1739 mock_quic_data_.AddWrite(SYNCHRONOUS,
1740 ConstructSettingsPacket(packet_number++));
1741 mock_quic_data_.AddWrite(SYNCHRONOUS,
1742 ConstructConnectRequestPacket(packet_number++));
1743 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1744 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1745
1746 mock_quic_data_.AddRead(
1747 ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED));
1748 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1749 std::string header = ConstructDataHeader(kLen2);
1750 mock_quic_data_.AddWrite(
1751 ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
1752 {header + std::string(kMsg2, kLen2)}));
1753 mock_quic_data_.AddWrite(
1754 SYNCHRONOUS, ConstructAckAndRstOnlyPacket(
1755 packet_number++, quic::QUIC_STREAM_CANCELLED, 2, 2));
1756
1757 Initialize();
1758
1759 AssertConnectSucceeds();
1760
1761 EXPECT_TRUE(sock_->IsConnected());
1762
1763 AssertReadStarts(kMsg1, kLen1);
1764
1765 // Write should block until the next read completes.
1766 // QuicChromiumClientStream::Handle::WriteStreamData() will only be
1767 // asynchronous starting with the second time it's called while the UDP socket
1768 // is write-blocked. Therefore, at least two writes need to be called on
1769 // |sock_| to get an asynchronous one.
1770 AssertWriteReturns(kMsg2, kLen2, kLen2);
1771
1772 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
1773
1774 ResumeAndRun();
1775
1776 EXPECT_TRUE(read_callback_.have_result());
1777 EXPECT_TRUE(write_callback_.have_result());
1778 }
1779
1780 // Makes sure the proxy client socket's source gets the expected NetLog events
1781 // and only the expected NetLog events (No SpdySession events).
TEST_P(QuicProxyClientSocketTest,NetLog)1782 TEST_P(QuicProxyClientSocketTest, NetLog) {
1783 int packet_number = 1;
1784 mock_quic_data_.AddWrite(SYNCHRONOUS,
1785 ConstructSettingsPacket(packet_number++));
1786 mock_quic_data_.AddWrite(SYNCHRONOUS,
1787 ConstructConnectRequestPacket(packet_number++));
1788 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1789 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1790
1791 std::string header = ConstructDataHeader(kLen1);
1792 mock_quic_data_.AddRead(
1793 ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
1794 mock_quic_data_.AddWrite(SYNCHRONOUS,
1795 ConstructAckPacket(packet_number++, 2, 1));
1796 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1797 mock_quic_data_.AddWrite(
1798 SYNCHRONOUS,
1799 ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
1800
1801 Initialize();
1802
1803 AssertConnectSucceeds();
1804
1805 ResumeAndRun();
1806 AssertSyncReadEquals(kMsg1, kLen1);
1807
1808 NetLogSource sock_source = sock_->NetLog().source();
1809 sock_.reset();
1810
1811 auto entry_list = net_log_observer_.GetEntriesForSource(sock_source);
1812
1813 ASSERT_EQ(entry_list.size(), 10u);
1814 EXPECT_TRUE(
1815 LogContainsBeginEvent(entry_list, 0, NetLogEventType::SOCKET_ALIVE));
1816 EXPECT_TRUE(LogContainsEvent(entry_list, 1,
1817 NetLogEventType::HTTP2_PROXY_CLIENT_SESSION,
1818 NetLogEventPhase::NONE));
1819 EXPECT_TRUE(LogContainsBeginEvent(
1820 entry_list, 2, NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
1821 EXPECT_TRUE(LogContainsEvent(
1822 entry_list, 3, NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
1823 NetLogEventPhase::NONE));
1824 EXPECT_TRUE(LogContainsEndEvent(
1825 entry_list, 4, NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
1826 EXPECT_TRUE(LogContainsBeginEvent(
1827 entry_list, 5, NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
1828 EXPECT_TRUE(LogContainsEvent(
1829 entry_list, 6,
1830 NetLogEventType::HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
1831 NetLogEventPhase::NONE));
1832 EXPECT_TRUE(LogContainsEndEvent(
1833 entry_list, 7, NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
1834 EXPECT_TRUE(LogContainsEvent(entry_list, 8,
1835 NetLogEventType::SOCKET_BYTES_RECEIVED,
1836 NetLogEventPhase::NONE));
1837 EXPECT_TRUE(
1838 LogContainsEndEvent(entry_list, 9, NetLogEventType::SOCKET_ALIVE));
1839 }
1840
1841 // A helper class that will delete |sock| when the callback is invoked.
1842 class DeleteSockCallback : public TestCompletionCallbackBase {
1843 public:
DeleteSockCallback(std::unique_ptr<QuicProxyClientSocket> * sock)1844 explicit DeleteSockCallback(std::unique_ptr<QuicProxyClientSocket>* sock)
1845 : sock_(sock) {}
1846
1847 DeleteSockCallback(const DeleteSockCallback&) = delete;
1848 DeleteSockCallback& operator=(const DeleteSockCallback&) = delete;
1849
1850 ~DeleteSockCallback() override = default;
1851
callback()1852 CompletionOnceCallback callback() {
1853 return base::BindOnce(&DeleteSockCallback::OnComplete,
1854 base::Unretained(this));
1855 }
1856
1857 private:
OnComplete(int result)1858 void OnComplete(int result) {
1859 sock_->reset(nullptr);
1860 SetResult(result);
1861 }
1862
1863 raw_ptr<std::unique_ptr<QuicProxyClientSocket>> sock_;
1864 };
1865
1866 // If the socket is reset when both a read and write are pending, and the
1867 // read callback causes the socket to be deleted, the write callback should
1868 // not be called.
TEST_P(QuicProxyClientSocketTest,RstWithReadAndWritePendingDelete)1869 TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
1870 int packet_number = 1;
1871 mock_quic_data_.AddWrite(SYNCHRONOUS,
1872 ConstructSettingsPacket(packet_number++));
1873 mock_quic_data_.AddWrite(SYNCHRONOUS,
1874 ConstructConnectRequestPacket(packet_number++));
1875 mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
1876 mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
1877
1878 mock_quic_data_.AddRead(
1879 ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED));
1880 mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1881 std::string header = ConstructDataHeader(kLen1);
1882 mock_quic_data_.AddWrite(
1883 ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
1884 {header + std::string(kMsg1, kLen1)}));
1885 mock_quic_data_.AddWrite(
1886 SYNCHRONOUS, ConstructAckAndRstOnlyPacket(
1887 packet_number++, quic::QUIC_STREAM_CANCELLED, 2, 2));
1888
1889 Initialize();
1890
1891 AssertConnectSucceeds();
1892
1893 EXPECT_TRUE(sock_->IsConnected());
1894
1895 DeleteSockCallback read_callback(&sock_);
1896 scoped_refptr<IOBuffer> read_buf = base::MakeRefCounted<IOBuffer>(kLen1);
1897 ASSERT_EQ(ERR_IO_PENDING,
1898 sock_->Read(read_buf.get(), kLen1, read_callback.callback()));
1899
1900 // QuicChromiumClientStream::Handle::WriteStreamData() will only be
1901 // asynchronous starting with the second time it's called while the UDP socket
1902 // is write-blocked. Therefore, at least two writes need to be called on
1903 // |sock_| to get an asynchronous one.
1904 AssertWriteReturns(kMsg1, kLen1, kLen1);
1905
1906 AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
1907
1908 ResumeAndRun();
1909
1910 EXPECT_FALSE(sock_.get());
1911
1912 EXPECT_EQ(0, read_callback.WaitForResult());
1913 EXPECT_FALSE(write_callback_.have_result());
1914 }
1915
1916 INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence,
1917 QuicProxyClientSocketTest,
1918 ::testing::ValuesIn(AllSupportedQuicVersions()),
1919 ::testing::PrintToStringParamName());
1920
1921 } // namespace net::test
1922