xref: /aosp_15_r20/external/cronet/net/quic/quic_proxy_client_socket_test_base.cc (revision 6777b5387eb2ff775bb5750e3f5d96f37fb7352b)
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