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