1 // Copyright 2024 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_test_base.h"
6
7 #include "base/memory/ptr_util.h"
8 #include "base/memory/raw_ptr.h"
9 #include "base/run_loop.h"
10 #include "base/strings/strcat.h"
11 #include "base/task/single_thread_task_runner.h"
12 #include "base/time/default_tick_clock.h"
13 #include "net/base/connection_endpoint_metadata.h"
14 #include "net/base/network_anonymization_key.h"
15 #include "net/base/privacy_mode.h"
16 #include "net/base/proxy_chain.h"
17 #include "net/base/proxy_server.h"
18 #include "net/base/proxy_string_util.h"
19 #include "net/base/session_usage.h"
20 #include "net/dns/mock_host_resolver.h"
21 #include "net/dns/public/host_resolver_results.h"
22 #include "net/dns/public/secure_dns_policy.h"
23 #include "net/http/transport_security_state.h"
24 #include "net/log/test_net_log.h"
25 #include "net/log/test_net_log_util.h"
26 #include "net/quic/crypto/proof_verifier_chromium.h"
27 #include "net/quic/mock_crypto_client_stream_factory.h"
28 #include "net/quic/quic_chromium_alarm_factory.h"
29 #include "net/quic/quic_chromium_client_session.h"
30 #include "net/quic/quic_chromium_connection_helper.h"
31 #include "net/quic/quic_chromium_packet_writer.h"
32 #include "net/quic/quic_crypto_client_config_handle.h"
33 #include "net/quic/quic_http_utils.h"
34 #include "net/quic/test_quic_crypto_client_config_handle.h"
35 #include "net/quic/test_task_runner.h"
36 #include "net/socket/socket_tag.h"
37 #include "net/socket/socket_test_util.h"
38 #include "net/ssl/ssl_config_service_defaults.h"
39 #include "net/test/cert_test_util.h"
40 #include "net/test/gtest_util.h"
41 #include "net/test/test_data_directory.h"
42 #include "net/test/test_with_task_environment.h"
43 #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
44 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h"
45 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
46 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
47 #include "url/scheme_host_port.h"
48
49 using testing::_;
50 using testing::AnyNumber;
51 using testing::Return;
52
53 namespace net {
54
55 QuicProxyClientSocketTestBase::~QuicProxyClientSocketTestBase() = default;
56
QuicProxyClientSocketTestBase()57 QuicProxyClientSocketTestBase::QuicProxyClientSocketTestBase()
58 : version_(GetParam()),
59 client_data_stream_id1_(quic::QuicUtils::GetFirstBidirectionalStreamId(
60 version_.transport_version,
61 quic::Perspective::IS_CLIENT)),
62 mock_quic_data_(version_),
63 crypto_config_(quic::test::crypto_test_utils::ProofVerifierForTesting()),
64 connection_id_(quic::test::TestConnectionId(2)),
65 client_maker_(version_,
66 connection_id_,
67 &clock_,
68 kProxyHost,
69 quic::Perspective::IS_CLIENT),
70 server_maker_(version_,
71 connection_id_,
72 &clock_,
73 kProxyHost,
74 quic::Perspective::IS_SERVER,
75 false),
76 user_agent_(kUserAgent),
77 proxy_endpoint_(url::kHttpsScheme, kProxyHost, kProxyPort),
78 destination_endpoint_(url::kHttpsScheme, kOriginHost, kOriginPort),
79 http_auth_cache_(
80 false /* key_server_entries_by_network_anonymization_key */),
81 host_resolver_(std::make_unique<MockCachingHostResolver>()),
82 http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()) {
83 FLAGS_quic_enable_http3_grease_randomness = false;
84 IPAddress ip(192, 0, 2, 33);
85 peer_addr_ = IPEndPoint(ip, 443);
86 clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20));
87 quic::QuicEnableVersion(version_);
88 }
89
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)90 size_t QuicProxyClientSocketTestBase::GetStreamFrameDataLengthFromPacketLength(
91 quic::QuicByteCount packet_length,
92 quic::ParsedQuicVersion version,
93 bool include_version,
94 bool include_diversification_nonce,
95 int connection_id_length,
96 quic::QuicPacketNumberLength packet_number_length,
97 quic::QuicStreamOffset offset) {
98 quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
99 quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
100 quiche::QuicheVariableLengthIntegerLength length_length =
101 include_version ? quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2
102 : quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
103 size_t min_data_length = 1;
104 size_t min_packet_length =
105 quic::test::TaggingEncrypter(quic::ENCRYPTION_FORWARD_SECURE)
106 .GetCiphertextSize(min_data_length) +
107 quic::QuicPacketCreator::StreamFramePacketOverhead(
108 version.transport_version, k8ByteConnectionId, k0ByteConnectionId,
109 include_version, include_diversification_nonce, packet_number_length,
110 retry_token_length_length, length_length, offset);
111
112 DCHECK(packet_length >= min_packet_length);
113 return min_data_length + packet_length - min_packet_length;
114 }
115
InitializeSession()116 void QuicProxyClientSocketTestBase::InitializeSession() {
117 auto socket = std::make_unique<MockUDPClientSocket>(
118 mock_quic_data_.InitializeAndGetSequencedSocketData(), NetLog::Get());
119 socket->Connect(peer_addr_);
120 runner_ = base::MakeRefCounted<test::TestTaskRunner>(&clock_);
121 send_algorithm_ = new quic::test::MockSendAlgorithm();
122 EXPECT_CALL(*send_algorithm_, InRecovery()).WillRepeatedly(Return(false));
123 EXPECT_CALL(*send_algorithm_, InSlowStart()).WillRepeatedly(Return(false));
124 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
125 .Times(testing::AtLeast(1));
126 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
127 .WillRepeatedly(Return(quic::kMaxOutgoingPacketSize));
128 EXPECT_CALL(*send_algorithm_, PacingRate(_))
129 .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
130 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
131 EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
132 .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
133 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
134 EXPECT_CALL(*send_algorithm_, OnApplicationLimited(_)).Times(AnyNumber());
135 EXPECT_CALL(*send_algorithm_, GetCongestionControlType()).Times(AnyNumber());
136 EXPECT_CALL(*send_algorithm_, PopulateConnectionStats(_)).Times(AnyNumber());
137 helper_ = std::make_unique<QuicChromiumConnectionHelper>(&clock_,
138 &random_generator_);
139 alarm_factory_ =
140 std::make_unique<QuicChromiumAlarmFactory>(runner_.get(), &clock_);
141
142 QuicChromiumPacketWriter* writer = new QuicChromiumPacketWriter(
143 socket.get(), base::SingleThreadTaskRunner::GetCurrentDefault().get());
144 quic::QuicConnection* connection = new quic::QuicConnection(
145 connection_id_, quic::QuicSocketAddress(),
146 net::ToQuicSocketAddress(peer_addr_), helper_.get(), alarm_factory_.get(),
147 writer, true /* owns_writer */, quic::Perspective::IS_CLIENT,
148 quic::test::SupportedVersions(version_), connection_id_generator_);
149 connection->set_visitor(&visitor_);
150 connection->SetEncrypter(quic::ENCRYPTION_FORWARD_SECURE,
151 std::make_unique<quic::test::TaggingEncrypter>(
152 quic::ENCRYPTION_FORWARD_SECURE));
153 quic::test::QuicConnectionPeer::SetSendAlgorithm(connection, send_algorithm_);
154
155 // Load a certificate that is valid for *.example.org
156 scoped_refptr<X509Certificate> test_cert(
157 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
158 EXPECT_TRUE(test_cert.get());
159
160 verify_details_.cert_verify_result.verified_cert = test_cert;
161 verify_details_.cert_verify_result.is_issued_by_known_root = true;
162 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
163
164 base::TimeTicks dns_end = base::TimeTicks::Now();
165 base::TimeTicks dns_start = dns_end - base::Milliseconds(1);
166
167 session_ = std::make_unique<QuicChromiumClientSession>(
168 connection, std::move(socket),
169 /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
170 &transport_security_state_, &ssl_config_service_,
171 base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
172 QuicSessionKey("mail.example.org", 80, PRIVACY_MODE_DISABLED,
173 proxy_chain_, SessionUsage::kDestination, SocketTag(),
174 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
175 /*require_dns_https_alpn=*/false),
176 /*require_confirmation=*/false,
177 /*migrate_session_early_v2=*/false,
178 /*migrate_session_on_network_change_v2=*/false,
179 /*default_network=*/handles::kInvalidNetworkHandle,
180 quic::QuicTime::Delta::FromMilliseconds(
181 kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
182 /*migrate_idle_session=*/true, /*allow_port_migration=*/false,
183 kDefaultIdleSessionMigrationPeriod, /*multi_port_probing_interval=*/0,
184 kMaxTimeOnNonDefaultNetwork,
185 kMaxMigrationsToNonDefaultNetworkOnWriteError,
186 kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
187 kQuicYieldAfterPacketsRead,
188 quic::QuicTime::Delta::FromMilliseconds(
189 kQuicYieldAfterDurationMilliseconds),
190 /*cert_verify_flags=*/0, quic::test::DefaultQuicConfig(),
191 std::make_unique<TestQuicCryptoClientConfigHandle>(&crypto_config_),
192 "CONNECTION_UNKNOWN", dns_start, dns_end,
193 base::DefaultTickClock::GetInstance(),
194 base::SingleThreadTaskRunner::GetCurrentDefault().get(),
195 /*socket_performance_watcher=*/nullptr, ConnectionEndpointMetadata(),
196 NetLogWithSource::Make(NetLogSourceType::NONE));
197
198 writer->set_delegate(session_.get());
199
200 session_->Initialize();
201
202 // Blackhole QPACK decoder stream instead of constructing mock writes.
203 session_->qpack_decoder()->set_qpack_stream_sender_delegate(
204 &noop_qpack_stream_sender_delegate_);
205
206 TestCompletionCallback callback;
207 EXPECT_THAT(session_->CryptoConnect(callback.callback()), test::IsOk());
208 EXPECT_TRUE(session_->OneRttKeysAvailable());
209
210 session_handle_ = session_->CreateHandle(
211 url::SchemeHostPort(url::kHttpsScheme, "mail.example.org", 80));
212 EXPECT_THAT(session_handle_->RequestStream(true, callback.callback(),
213 TRAFFIC_ANNOTATION_FOR_TESTS),
214 test::IsOk());
215
216 stream_handle_ = session_handle_->ReleaseStream();
217 EXPECT_TRUE(stream_handle_->IsOpen());
218 }
219
220 // Helper functions for constructing packets sent by the client
221
222 std::unique_ptr<quic::QuicReceivedPacket>
ConstructSettingsPacket(uint64_t packet_number)223 QuicProxyClientSocketTestBase::ConstructSettingsPacket(uint64_t packet_number) {
224 return client_maker_.MakeInitialSettingsPacket(packet_number);
225 }
226
227 std::unique_ptr<quic::QuicReceivedPacket>
ConstructAckAndRstOnlyPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code,uint64_t largest_received,uint64_t smallest_received)228 QuicProxyClientSocketTestBase::ConstructAckAndRstOnlyPacket(
229 uint64_t packet_number,
230 quic::QuicRstStreamErrorCode error_code,
231 uint64_t largest_received,
232 uint64_t smallest_received) {
233 return client_maker_.MakeAckAndRstPacket(
234 packet_number, client_data_stream_id1_, error_code, largest_received,
235 smallest_received,
236 /*include_stop_sending_if_v99=*/false);
237 }
238
239 std::unique_ptr<quic::QuicReceivedPacket>
ConstructAckAndRstPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code,uint64_t largest_received,uint64_t smallest_received)240 QuicProxyClientSocketTestBase::ConstructAckAndRstPacket(
241 uint64_t packet_number,
242 quic::QuicRstStreamErrorCode error_code,
243 uint64_t largest_received,
244 uint64_t smallest_received) {
245 return client_maker_.MakeAckAndRstPacket(
246 packet_number, client_data_stream_id1_, error_code, largest_received,
247 smallest_received,
248 /*include_stop_sending_if_v99=*/true);
249 }
250
251 std::unique_ptr<quic::QuicReceivedPacket>
ConstructRstPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code)252 QuicProxyClientSocketTestBase::ConstructRstPacket(
253 uint64_t packet_number,
254 quic::QuicRstStreamErrorCode error_code) {
255 return client_maker_.MakeRstPacket(packet_number, client_data_stream_id1_,
256 error_code,
257 /*include_stop_sending_if_v99=*/true);
258 }
259
260 std::unique_ptr<quic::QuicReceivedPacket>
ConstructConnectRequestPacket(uint64_t packet_number,std::optional<const HttpRequestHeaders> extra_headers,RequestPriority request_priority)261 QuicProxyClientSocketTestBase::ConstructConnectRequestPacket(
262 uint64_t packet_number,
263 std::optional<const HttpRequestHeaders> extra_headers,
264 RequestPriority request_priority) {
265 spdy::Http2HeaderBlock block;
266 PopulateConnectRequestIR(&block, extra_headers);
267 return client_maker_.MakeRequestHeadersPacket(
268 packet_number, client_data_stream_id1_, !kFin,
269 ConvertRequestPriorityToQuicPriority(request_priority), std::move(block),
270 nullptr);
271 }
272
273 std::unique_ptr<quic::QuicReceivedPacket>
ConstructConnectRequestPacketWithExtraHeaders(uint64_t packet_number,std::vector<std::pair<std::string,std::string>> extra_headers,RequestPriority request_priority)274 QuicProxyClientSocketTestBase::ConstructConnectRequestPacketWithExtraHeaders(
275 uint64_t packet_number,
276 std::vector<std::pair<std::string, std::string>> extra_headers,
277 RequestPriority request_priority) {
278 spdy::Http2HeaderBlock block;
279 block[":method"] = "CONNECT";
280 block[":authority"] =
281 HostPortPair::FromSchemeHostPort(destination_endpoint_).ToString();
282 for (const auto& header : extra_headers) {
283 block[header.first] = header.second;
284 }
285 return client_maker_.MakeRequestHeadersPacket(
286 packet_number, client_data_stream_id1_, !kFin,
287 ConvertRequestPriorityToQuicPriority(request_priority), std::move(block),
288 nullptr);
289 }
290
291 std::unique_ptr<quic::QuicReceivedPacket>
ConstructConnectAuthRequestPacket(uint64_t packet_number)292 QuicProxyClientSocketTestBase::ConstructConnectAuthRequestPacket(
293 uint64_t packet_number) {
294 RequestPriority request_priority = LOWEST;
295 spdy::Http2HeaderBlock block;
296 PopulateConnectRequestIR(&block, /*extra_headers=*/std::nullopt);
297 block["proxy-authorization"] = "Basic Zm9vOmJhcg==";
298 return client_maker_.MakeRequestHeadersPacket(
299 packet_number, client_data_stream_id1_, !kFin,
300 ConvertRequestPriorityToQuicPriority(request_priority), std::move(block),
301 nullptr);
302 }
303
304 std::unique_ptr<quic::QuicReceivedPacket>
ConstructDataPacket(uint64_t packet_number,std::string_view data)305 QuicProxyClientSocketTestBase::ConstructDataPacket(uint64_t packet_number,
306 std::string_view data) {
307 return client_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
308 !kFin, data);
309 }
310
311 std::unique_ptr<quic::QuicReceivedPacket>
ConstructDatagramPacket(uint64_t packet_number,std::string_view data)312 QuicProxyClientSocketTestBase::ConstructDatagramPacket(uint64_t packet_number,
313 std::string_view data) {
314 return client_maker_.MakeDatagramPacket(packet_number, data);
315 }
316
317 std::unique_ptr<quic::QuicReceivedPacket>
ConstructAckAndDataPacket(uint64_t packet_number,uint64_t largest_received,uint64_t smallest_received,std::string_view data)318 QuicProxyClientSocketTestBase::ConstructAckAndDataPacket(
319 uint64_t packet_number,
320 uint64_t largest_received,
321 uint64_t smallest_received,
322 std::string_view data) {
323 return client_maker_.MakeAckAndDataPacket(
324 packet_number, client_data_stream_id1_, largest_received,
325 smallest_received, !kFin, data);
326 }
327
328 std::unique_ptr<quic::QuicReceivedPacket>
ConstructAckAndDatagramPacket(uint64_t packet_number,uint64_t largest_received,uint64_t smallest_received,std::string_view data)329 QuicProxyClientSocketTestBase::ConstructAckAndDatagramPacket(
330 uint64_t packet_number,
331 uint64_t largest_received,
332 uint64_t smallest_received,
333 std::string_view data) {
334 return client_maker_.MakeAckAndDatagramPacket(packet_number, largest_received,
335 smallest_received, data);
336 }
337
338 std::unique_ptr<quic::QuicReceivedPacket>
ConstructAckPacket(uint64_t packet_number,uint64_t largest_received,uint64_t smallest_received)339 QuicProxyClientSocketTestBase::ConstructAckPacket(uint64_t packet_number,
340 uint64_t largest_received,
341 uint64_t smallest_received) {
342 return client_maker_.MakeAckPacket(packet_number, largest_received,
343 smallest_received);
344 }
345
346 // Helper functions for constructing packets sent by the server
347
348 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerRstPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code)349 QuicProxyClientSocketTestBase::ConstructServerRstPacket(
350 uint64_t packet_number,
351 quic::QuicRstStreamErrorCode error_code) {
352 return server_maker_.MakeRstPacket(packet_number, client_data_stream_id1_,
353 error_code,
354 /*include_stop_sending_if_v99=*/true);
355 }
356
357 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerDataPacket(uint64_t packet_number,std::string_view data)358 QuicProxyClientSocketTestBase::ConstructServerDataPacket(
359 uint64_t packet_number,
360 std::string_view data) {
361 return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
362 !kFin, data);
363 }
364
365 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerDatagramPacket(uint64_t packet_number,std::string_view data)366 QuicProxyClientSocketTestBase::ConstructServerDatagramPacket(
367 uint64_t packet_number,
368 std::string_view data) {
369 return server_maker_.MakeDatagramPacket(packet_number, data);
370 }
371
372 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerDataFinPacket(uint64_t packet_number,std::string_view data)373 QuicProxyClientSocketTestBase::ConstructServerDataFinPacket(
374 uint64_t packet_number,
375 std::string_view data) {
376 return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
377 kFin, data);
378 }
379
380 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectReplyPacket(uint64_t packet_number,bool fin,size_t * header_length,std::optional<const HttpRequestHeaders> extra_headers)381 QuicProxyClientSocketTestBase::ConstructServerConnectReplyPacket(
382 uint64_t packet_number,
383 bool fin,
384 size_t* header_length,
385 std::optional<const HttpRequestHeaders> extra_headers) {
386 spdy::Http2HeaderBlock block;
387 block[":status"] = "200";
388
389 if (extra_headers) {
390 HttpRequestHeaders::Iterator it(*extra_headers);
391 while (it.GetNext()) {
392 std::string name = base::ToLowerASCII(it.name());
393 block[name] = it.value();
394 }
395 }
396
397 return server_maker_.MakeResponseHeadersPacket(
398 packet_number, client_data_stream_id1_, fin, std::move(block),
399 header_length);
400 }
401
402 std::unique_ptr<quic::QuicReceivedPacket> QuicProxyClientSocketTestBase::
ConstructServerConnectReplyPacketWithExtraHeaders(uint64_t packet_number,bool fin,std::vector<std::pair<std::string,std::string>> extra_headers)403 ConstructServerConnectReplyPacketWithExtraHeaders(
404 uint64_t packet_number,
405 bool fin,
406 std::vector<std::pair<std::string, std::string>> extra_headers) {
407 spdy::Http2HeaderBlock block;
408 block[":status"] = "200";
409 for (const auto& header : extra_headers) {
410 block[header.first] = header.second;
411 }
412
413 return server_maker_.MakeResponseHeadersPacket(
414 packet_number, client_data_stream_id1_, fin, std::move(block), nullptr);
415 }
416
417 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectAuthReplyPacket(uint64_t packet_number,bool fin)418 QuicProxyClientSocketTestBase::ConstructServerConnectAuthReplyPacket(
419 uint64_t packet_number,
420 bool fin) {
421 spdy::Http2HeaderBlock block;
422 block[":status"] = "407";
423 block["proxy-authenticate"] = "Basic realm=\"MyRealm1\"";
424 return server_maker_.MakeResponseHeadersPacket(
425 packet_number, client_data_stream_id1_, fin, std::move(block), nullptr);
426 }
427
428 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectRedirectReplyPacket(uint64_t packet_number,bool fin)429 QuicProxyClientSocketTestBase::ConstructServerConnectRedirectReplyPacket(
430 uint64_t packet_number,
431 bool fin) {
432 spdy::Http2HeaderBlock block;
433 block[":status"] = "302";
434 block["location"] = kRedirectUrl;
435 block["set-cookie"] = "foo=bar";
436 return server_maker_.MakeResponseHeadersPacket(
437 packet_number, client_data_stream_id1_, fin, std::move(block), nullptr);
438 }
439
440 std::unique_ptr<quic::QuicReceivedPacket>
ConstructServerConnectErrorReplyPacket(uint64_t packet_number,bool fin)441 QuicProxyClientSocketTestBase::ConstructServerConnectErrorReplyPacket(
442 uint64_t packet_number,
443 bool fin) {
444 spdy::Http2HeaderBlock block;
445 block[":status"] = "500";
446
447 return server_maker_.MakeResponseHeadersPacket(
448 packet_number, client_data_stream_id1_, fin, std::move(block), nullptr);
449 }
450
ResumeAndRun()451 void QuicProxyClientSocketTestBase::ResumeAndRun() {
452 // Run until the pause, if the provider isn't paused yet.
453 SequencedSocketData* data = mock_quic_data_.GetSequencedSocketData();
454 data->RunUntilPaused();
455 data->Resume();
456 base::RunLoop().RunUntilIdle();
457 }
458
ConstructDataHeader(size_t body_len)459 std::string QuicProxyClientSocketTestBase::ConstructDataHeader(
460 size_t body_len) {
461 quiche::QuicheBuffer buffer = quic::HttpEncoder::SerializeDataFrameHeader(
462 body_len, quiche::SimpleBufferAllocator::Get());
463 return std::string(buffer.data(), buffer.size());
464 }
465 } // namespace net
466