123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091 |
- // Copyright (c) 2017 The Chromium Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
- // found in the LICENSE file.
- #include "net/quic/quic_proxy_client_socket.h"
- #include <memory>
- #include <tuple>
- #include <utility>
- #include <vector>
- #include "base/bind.h"
- #include "base/memory/ptr_util.h"
- #include "base/memory/raw_ptr.h"
- #include "base/run_loop.h"
- #include "base/strings/strcat.h"
- #include "base/strings/utf_string_conversions.h"
- #include "base/threading/thread_task_runner_handle.h"
- #include "base/time/default_tick_clock.h"
- #include "net/base/proxy_server.h"
- #include "net/base/proxy_string_util.h"
- #include "net/base/test_proxy_delegate.h"
- #include "net/dns/mock_host_resolver.h"
- #include "net/dns/public/secure_dns_policy.h"
- #include "net/http/http_auth_cache.h"
- #include "net/http/http_auth_handler_factory.h"
- #include "net/http/http_response_headers.h"
- #include "net/http/transport_security_state.h"
- #include "net/log/net_log.h"
- #include "net/log/test_net_log.h"
- #include "net/log/test_net_log_util.h"
- #include "net/quic/address_utils.h"
- #include "net/quic/crypto/proof_verifier_chromium.h"
- #include "net/quic/mock_crypto_client_stream_factory.h"
- #include "net/quic/mock_quic_data.h"
- #include "net/quic/quic_chromium_alarm_factory.h"
- #include "net/quic/quic_chromium_client_session.h"
- #include "net/quic/quic_chromium_connection_helper.h"
- #include "net/quic/quic_chromium_packet_writer.h"
- #include "net/quic/quic_crypto_client_config_handle.h"
- #include "net/quic/quic_http_utils.h"
- #include "net/quic/quic_server_info.h"
- #include "net/quic/quic_stream_factory.h"
- #include "net/quic/quic_test_packet_maker.h"
- #include "net/quic/test_quic_crypto_client_config_handle.h"
- #include "net/quic/test_task_runner.h"
- #include "net/socket/socket_test_util.h"
- #include "net/test/cert_test_util.h"
- #include "net/test/gtest_util.h"
- #include "net/test/test_data_directory.h"
- #include "net/test/test_with_task_environment.h"
- #include "net/third_party/quiche/src/quiche/quic/core/crypto/null_encrypter.h"
- #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
- #include "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.h"
- #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_clock.h"
- #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h"
- #include "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_test_utils.h"
- #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_connection_peer.h"
- #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
- #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
- #include "testing/gmock/include/gmock/gmock.h"
- #include "testing/gtest/include/gtest/gtest.h"
- #include "url/gurl.h"
- #include "url/scheme_host_port.h"
- #include "url/url_constants.h"
- using testing::_;
- using testing::AnyNumber;
- using testing::Return;
- namespace net::test {
- namespace {
- static const char kOriginHost[] = "www.google.com";
- static const int kOriginPort = 443;
- static const char kProxyUrl[] = "https://myproxy:6121/";
- static const char kProxyHost[] = "myproxy";
- static const int kProxyPort = 6121;
- static const char kUserAgent[] = "Mozilla/1.0";
- static const char kRedirectUrl[] = "https://example.com/";
- static const char kMsg1[] = "\0hello!\xff";
- static const int kLen1 = 8;
- static const char kMsg2[] = "\0a2345678\0";
- static const int kLen2 = 10;
- static const char kMsg3[] = "bye!";
- static const int kLen3 = 4;
- static const char kMsg33[] = "bye!bye!";
- static const int kLen33 = kLen3 + kLen3;
- static const char kMsg333[] = "bye!bye!bye!";
- static const int kLen333 = kLen3 + kLen3 + kLen3;
- struct TestParams {
- quic::ParsedQuicVersion version;
- bool client_headers_include_h2_stream_dependency;
- };
- // Used by ::testing::PrintToStringParamName().
- std::string PrintToString(const TestParams& p) {
- return base::StrCat(
- {ParsedQuicVersionToString(p.version), "_",
- (p.client_headers_include_h2_stream_dependency ? "" : "No"),
- "Dependency"});
- }
- std::vector<TestParams> GetTestParams() {
- std::vector<TestParams> params;
- quic::ParsedQuicVersionVector all_supported_versions =
- quic::AllSupportedVersions();
- for (const auto& version : all_supported_versions) {
- params.push_back(TestParams{version, false});
- params.push_back(TestParams{version, true});
- }
- return params;
- }
- } // anonymous namespace
- class QuicProxyClientSocketTest : public ::testing::TestWithParam<TestParams>,
- public WithTaskEnvironment {
- protected:
- static const bool kFin = true;
- static const bool kIncludeVersion = true;
- static const bool kIncludeDiversificationNonce = true;
- static size_t GetStreamFrameDataLengthFromPacketLength(
- quic::QuicByteCount packet_length,
- quic::ParsedQuicVersion version,
- bool include_version,
- bool include_diversification_nonce,
- quic::QuicConnectionIdLength connection_id_length,
- quic::QuicPacketNumberLength packet_number_length,
- quic::QuicStreamOffset offset) {
- quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
- quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
- quiche::QuicheVariableLengthIntegerLength length_length =
- quic::QuicVersionHasLongHeaderLengths(version.transport_version) &&
- include_version
- ? quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2
- : quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
- size_t min_data_length = 1;
- size_t min_packet_length =
- quic::NullEncrypter(quic::Perspective::IS_CLIENT)
- .GetCiphertextSize(min_data_length) +
- quic::QuicPacketCreator::StreamFramePacketOverhead(
- version.transport_version, quic::PACKET_8BYTE_CONNECTION_ID,
- quic::PACKET_0BYTE_CONNECTION_ID, include_version,
- include_diversification_nonce, packet_number_length,
- retry_token_length_length, length_length, offset);
- DCHECK(packet_length >= min_packet_length);
- return min_data_length + packet_length - min_packet_length;
- }
- QuicProxyClientSocketTest()
- : version_(GetParam().version),
- client_data_stream_id1_(
- quic::VersionUsesHttp3(version_.transport_version)
- ? quic::QuicUtils::GetFirstBidirectionalStreamId(
- version_.transport_version,
- quic::Perspective::IS_CLIENT)
- : quic::QuicUtils::GetFirstBidirectionalStreamId(
- version_.transport_version,
- quic::Perspective::IS_CLIENT) +
- quic::QuicUtils::StreamIdDelta(
- version_.transport_version)),
- client_headers_include_h2_stream_dependency_(
- GetParam().client_headers_include_h2_stream_dependency),
- mock_quic_data_(version_),
- crypto_config_(
- quic::test::crypto_test_utils::ProofVerifierForTesting()),
- connection_id_(quic::test::TestConnectionId(2)),
- client_maker_(version_,
- connection_id_,
- &clock_,
- kProxyHost,
- quic::Perspective::IS_CLIENT,
- client_headers_include_h2_stream_dependency_),
- server_maker_(version_,
- connection_id_,
- &clock_,
- kProxyHost,
- quic::Perspective::IS_SERVER,
- false),
- user_agent_(kUserAgent),
- proxy_endpoint_(url::kHttpsScheme, kProxyHost, kProxyPort),
- destination_endpoint_(url::kHttpsScheme, kOriginHost, kOriginPort),
- http_auth_cache_(
- false /* key_server_entries_by_network_isolation_key */),
- host_resolver_(std::make_unique<MockCachingHostResolver>()),
- http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()) {
- FLAGS_quic_enable_http3_grease_randomness = false;
- IPAddress ip(192, 0, 2, 33);
- peer_addr_ = IPEndPoint(ip, 443);
- clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20));
- quic::QuicEnableVersion(version_);
- }
- QuicProxyClientSocketTest(const QuicProxyClientSocketTest&) = delete;
- QuicProxyClientSocketTest& operator=(const QuicProxyClientSocketTest&) =
- delete;
- void SetUp() override {}
- void TearDown() override {
- sock_.reset();
- EXPECT_TRUE(mock_quic_data_.AllReadDataConsumed());
- EXPECT_TRUE(mock_quic_data_.AllWriteDataConsumed());
- }
- void Initialize() {
- auto socket = std::make_unique<MockUDPClientSocket>(
- mock_quic_data_.InitializeAndGetSequencedSocketData(), NetLog::Get());
- socket->Connect(peer_addr_);
- runner_ = base::MakeRefCounted<TestTaskRunner>(&clock_);
- send_algorithm_ = new quic::test::MockSendAlgorithm();
- EXPECT_CALL(*send_algorithm_, InRecovery()).WillRepeatedly(Return(false));
- EXPECT_CALL(*send_algorithm_, InSlowStart()).WillRepeatedly(Return(false));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .Times(testing::AtLeast(1));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillRepeatedly(Return(quic::kMaxOutgoingPacketSize));
- EXPECT_CALL(*send_algorithm_, PacingRate(_))
- .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
- EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
- EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
- .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
- EXPECT_CALL(*send_algorithm_, OnApplicationLimited(_)).Times(AnyNumber());
- EXPECT_CALL(*send_algorithm_, GetCongestionControlType())
- .Times(AnyNumber());
- helper_ = std::make_unique<QuicChromiumConnectionHelper>(
- &clock_, &random_generator_);
- alarm_factory_ =
- std::make_unique<QuicChromiumAlarmFactory>(runner_.get(), &clock_);
- QuicChromiumPacketWriter* writer = new QuicChromiumPacketWriter(
- socket.get(), base::ThreadTaskRunnerHandle::Get().get());
- quic::QuicConnection* connection = new quic::QuicConnection(
- connection_id_, quic::QuicSocketAddress(),
- net::ToQuicSocketAddress(peer_addr_), helper_.get(),
- alarm_factory_.get(), writer, true /* owns_writer */,
- quic::Perspective::IS_CLIENT, quic::test::SupportedVersions(version_));
- connection->set_visitor(&visitor_);
- quic::test::QuicConnectionPeer::SetSendAlgorithm(connection,
- send_algorithm_);
- // Load a certificate that is valid for *.example.org
- scoped_refptr<X509Certificate> test_cert(
- ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
- EXPECT_TRUE(test_cert.get());
- verify_details_.cert_verify_result.verified_cert = test_cert;
- verify_details_.cert_verify_result.is_issued_by_known_root = true;
- crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
- base::TimeTicks dns_end = base::TimeTicks::Now();
- base::TimeTicks dns_start = dns_end - base::Milliseconds(1);
- session_ = std::make_unique<QuicChromiumClientSession>(
- connection, std::move(socket),
- /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
- &transport_security_state_, /*ssl_config_service=*/nullptr,
- base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
- QuicSessionKey("mail.example.org", 80, PRIVACY_MODE_DISABLED,
- SocketTag(), NetworkIsolationKey(),
- SecureDnsPolicy::kAllow,
- /*require_dns_https_alpn=*/false),
- /*require_confirmation=*/false,
- /*migrate_session_early_v2=*/false,
- /*migrate_session_on_network_change_v2=*/false,
- /*default_network=*/handles::kInvalidNetworkHandle,
- quic::QuicTime::Delta::FromMilliseconds(
- kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
- /*migrate_idle_session=*/true, /*allow_port_migration=*/false,
- kDefaultIdleSessionMigrationPeriod, kMaxTimeOnNonDefaultNetwork,
- kMaxMigrationsToNonDefaultNetworkOnWriteError,
- kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
- kQuicYieldAfterPacketsRead,
- quic::QuicTime::Delta::FromMilliseconds(
- kQuicYieldAfterDurationMilliseconds),
- client_headers_include_h2_stream_dependency_, /*cert_verify_flags=*/0,
- quic::test::DefaultQuicConfig(),
- std::make_unique<TestQuicCryptoClientConfigHandle>(&crypto_config_),
- "CONNECTION_UNKNOWN", dns_start, dns_end,
- std::make_unique<quic::QuicClientPushPromiseIndex>(), nullptr,
- base::DefaultTickClock::GetInstance(),
- base::ThreadTaskRunnerHandle::Get().get(),
- /*socket_performance_watcher=*/nullptr, NetLog::Get());
- writer->set_delegate(session_.get());
- session_->Initialize();
- // Blackhole QPACK decoder stream instead of constructing mock writes.
- if (VersionUsesHttp3(version_.transport_version)) {
- session_->qpack_decoder()->set_qpack_stream_sender_delegate(
- &noop_qpack_stream_sender_delegate_);
- }
- TestCompletionCallback callback;
- EXPECT_THAT(session_->CryptoConnect(callback.callback()), IsOk());
- EXPECT_TRUE(session_->OneRttKeysAvailable());
- session_handle_ = session_->CreateHandle(
- url::SchemeHostPort(url::kHttpsScheme, "mail.example.org", 80));
- EXPECT_THAT(session_handle_->RequestStream(true, callback.callback(),
- TRAFFIC_ANNOTATION_FOR_TESTS),
- IsOk());
- std::unique_ptr<QuicChromiumClientStream::Handle> stream_handle =
- session_handle_->ReleaseStream();
- EXPECT_TRUE(stream_handle->IsOpen());
- sock_ = std::make_unique<QuicProxyClientSocket>(
- std::move(stream_handle), std::move(session_handle_),
- // TODO(crbug.com/1206799) Construct `ProxyServer` with plain
- // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
- ProxyServer(ProxyServer::SCHEME_HTTPS,
- HostPortPair::FromSchemeHostPort(proxy_endpoint_)),
- user_agent_,
- // TODO(crbug.com/1206799) Construct `QuicProxyClientSocket` with plain
- // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
- HostPortPair::FromSchemeHostPort(destination_endpoint_),
- NetLogWithSource::Make(NetLogSourceType::NONE),
- base::MakeRefCounted<HttpAuthController>(
- HttpAuth::AUTH_PROXY, proxy_endpoint_.GetURL(),
- NetworkIsolationKey(), &http_auth_cache_,
- http_auth_handler_factory_.get(), host_resolver_.get()),
- proxy_delegate_.get());
- session_->StartReading();
- }
- void PopulateConnectRequestIR(spdy::Http2HeaderBlock* block) {
- (*block)[":method"] = "CONNECT";
- (*block)[":authority"] =
- HostPortPair::FromSchemeHostPort(destination_endpoint_).ToString();
- (*block)["user-agent"] = kUserAgent;
- }
- // Helper functions for constructing packets sent by the client
- std::unique_ptr<quic::QuicReceivedPacket> ConstructSettingsPacket(
- uint64_t packet_number) {
- return client_maker_.MakeInitialSettingsPacket(packet_number);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndRstOnlyPacket(
- uint64_t packet_number,
- quic::QuicRstStreamErrorCode error_code,
- uint64_t largest_received,
- uint64_t smallest_received) {
- return client_maker_.MakeAckAndRstPacket(
- packet_number, !kIncludeVersion, client_data_stream_id1_, error_code,
- largest_received, smallest_received,
- /*include_stop_sending_if_v99=*/false);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndRstPacket(
- uint64_t packet_number,
- quic::QuicRstStreamErrorCode error_code,
- uint64_t largest_received,
- uint64_t smallest_received) {
- return client_maker_.MakeAckAndRstPacket(
- packet_number, !kIncludeVersion, client_data_stream_id1_, error_code,
- largest_received, smallest_received,
- /*include_stop_sending_if_v99=*/true);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructRstPacket(
- uint64_t packet_number,
- quic::QuicRstStreamErrorCode error_code) {
- return client_maker_.MakeRstPacket(packet_number, !kIncludeVersion,
- client_data_stream_id1_, error_code,
- /*include_stop_sending_if_v99=*/true);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructConnectRequestPacket(
- uint64_t packet_number,
- RequestPriority request_priority = LOWEST) {
- spdy::Http2HeaderBlock block;
- PopulateConnectRequestIR(&block);
- return client_maker_.MakeRequestHeadersPacket(
- packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
- ConvertRequestPriorityToQuicPriority(request_priority),
- std::move(block), 0, nullptr);
- }
- std::unique_ptr<quic::QuicReceivedPacket>
- ConstructConnectRequestPacketWithExtraHeaders(
- uint64_t packet_number,
- std::vector<std::pair<std::string, std::string>> extra_headers,
- RequestPriority request_priority = LOWEST) {
- spdy::Http2HeaderBlock block;
- block[":method"] = "CONNECT";
- block[":authority"] =
- HostPortPair::FromSchemeHostPort(destination_endpoint_).ToString();
- for (const auto& header : extra_headers) {
- block[header.first] = header.second;
- }
- return client_maker_.MakeRequestHeadersPacket(
- packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
- ConvertRequestPriorityToQuicPriority(request_priority),
- std::move(block), 0, nullptr);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructConnectAuthRequestPacket(
- uint64_t packet_number) {
- RequestPriority request_priority = LOWEST;
- spdy::Http2HeaderBlock block;
- PopulateConnectRequestIR(&block);
- block["proxy-authorization"] = "Basic Zm9vOmJhcg==";
- return client_maker_.MakeRequestHeadersPacket(
- packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
- ConvertRequestPriorityToQuicPriority(request_priority),
- std::move(block), 0, nullptr);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructDataPacket(
- uint64_t packet_number,
- absl::string_view data) {
- return client_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
- !kIncludeVersion, !kFin, data);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndDataPacket(
- uint64_t packet_number,
- uint64_t largest_received,
- uint64_t smallest_received,
- absl::string_view data) {
- return client_maker_.MakeAckAndDataPacket(
- packet_number, !kIncludeVersion, client_data_stream_id1_,
- largest_received, smallest_received, !kFin, data);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructAckPacket(
- uint64_t packet_number,
- uint64_t largest_received,
- uint64_t smallest_received) {
- return client_maker_.MakeAckPacket(packet_number, largest_received,
- smallest_received);
- }
- // Helper functions for constructing packets sent by the server
- std::unique_ptr<quic::QuicReceivedPacket> ConstructServerRstPacket(
- uint64_t packet_number,
- quic::QuicRstStreamErrorCode error_code) {
- return server_maker_.MakeRstPacket(packet_number, !kIncludeVersion,
- client_data_stream_id1_, error_code,
- /*include_stop_sending_if_v99=*/true);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataPacket(
- uint64_t packet_number,
- absl::string_view data) {
- return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
- !kIncludeVersion, !kFin, data);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataFinPacket(
- uint64_t packet_number,
- absl::string_view data) {
- return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
- !kIncludeVersion, kFin, data);
- }
- std::unique_ptr<quic::QuicReceivedPacket> ConstructServerConnectReplyPacket(
- uint64_t packet_number,
- bool fin,
- size_t* header_length = nullptr) {
- spdy::Http2HeaderBlock block;
- block[":status"] = "200";
- return server_maker_.MakeResponseHeadersPacket(
- packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
- std::move(block), header_length);
- }
- std::unique_ptr<quic::QuicReceivedPacket>
- ConstructServerConnectReplyPacketWithExtraHeaders(
- uint64_t packet_number,
- bool fin,
- std::vector<std::pair<std::string, std::string>> extra_headers) {
- spdy::Http2HeaderBlock block;
- block[":status"] = "200";
- for (const auto& header : extra_headers) {
- block[header.first] = header.second;
- }
- return server_maker_.MakeResponseHeadersPacket(
- packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
- std::move(block), nullptr);
- }
- std::unique_ptr<quic::QuicReceivedPacket>
- ConstructServerConnectAuthReplyPacket(uint64_t packet_number, bool fin) {
- spdy::Http2HeaderBlock block;
- block[":status"] = "407";
- block["proxy-authenticate"] = "Basic realm=\"MyRealm1\"";
- return server_maker_.MakeResponseHeadersPacket(
- packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
- std::move(block), nullptr);
- }
- std::unique_ptr<quic::QuicReceivedPacket>
- ConstructServerConnectRedirectReplyPacket(uint64_t packet_number, bool fin) {
- spdy::Http2HeaderBlock block;
- block[":status"] = "302";
- block["location"] = kRedirectUrl;
- block["set-cookie"] = "foo=bar";
- return server_maker_.MakeResponseHeadersPacket(
- packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
- std::move(block), nullptr);
- }
- std::unique_ptr<quic::QuicReceivedPacket>
- ConstructServerConnectErrorReplyPacket(uint64_t packet_number, bool fin) {
- spdy::Http2HeaderBlock block;
- block[":status"] = "500";
- return server_maker_.MakeResponseHeadersPacket(
- packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
- std::move(block), nullptr);
- }
- void AssertConnectSucceeds() {
- TestCompletionCallback callback;
- ASSERT_THAT(sock_->Connect(callback.callback()), IsError(ERR_IO_PENDING));
- ASSERT_THAT(callback.WaitForResult(), IsOk());
- }
- void AssertConnectFails(int result) {
- TestCompletionCallback callback;
- ASSERT_THAT(sock_->Connect(callback.callback()), IsError(ERR_IO_PENDING));
- ASSERT_EQ(result, callback.WaitForResult());
- }
- void ResumeAndRun() {
- // Run until the pause, if the provider isn't paused yet.
- SequencedSocketData* data = mock_quic_data_.GetSequencedSocketData();
- data->RunUntilPaused();
- data->Resume();
- base::RunLoop().RunUntilIdle();
- }
- void AssertWriteReturns(const char* data, int len, int rv) {
- scoped_refptr<IOBufferWithSize> buf =
- base::MakeRefCounted<IOBufferWithSize>(len);
- memcpy(buf->data(), data, len);
- EXPECT_EQ(rv,
- sock_->Write(buf.get(), buf->size(), write_callback_.callback(),
- TRAFFIC_ANNOTATION_FOR_TESTS));
- }
- void AssertSyncWriteSucceeds(const char* data, int len) {
- scoped_refptr<IOBufferWithSize> buf =
- base::MakeRefCounted<IOBufferWithSize>(len);
- memcpy(buf->data(), data, len);
- EXPECT_EQ(len,
- sock_->Write(buf.get(), buf->size(), CompletionOnceCallback(),
- TRAFFIC_ANNOTATION_FOR_TESTS));
- }
- void AssertSyncReadEquals(const char* data, int len) {
- scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
- ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionOnceCallback()));
- ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
- ASSERT_TRUE(sock_->IsConnected());
- }
- void AssertAsyncReadEquals(const char* data, int len) {
- scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
- ASSERT_EQ(ERR_IO_PENDING,
- sock_->Read(buf.get(), len, read_callback_.callback()));
- EXPECT_TRUE(sock_->IsConnected());
- ResumeAndRun();
- EXPECT_EQ(len, read_callback_.WaitForResult());
- EXPECT_TRUE(sock_->IsConnected());
- ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
- }
- void AssertReadStarts(const char* data, int len) {
- // Issue the read, which will be completed asynchronously.
- read_buf_ = base::MakeRefCounted<IOBuffer>(len);
- ASSERT_EQ(ERR_IO_PENDING,
- sock_->Read(read_buf_.get(), len, read_callback_.callback()));
- EXPECT_TRUE(sock_->IsConnected());
- }
- void AssertReadReturns(const char* data, int len) {
- EXPECT_TRUE(sock_->IsConnected());
- // Now the read will return.
- EXPECT_EQ(len, read_callback_.WaitForResult());
- ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
- }
- std::string ConstructDataHeader(size_t body_len) {
- if (!version_.HasIetfQuicFrames()) {
- return "";
- }
- quiche::QuicheBuffer buffer = quic::HttpEncoder::SerializeDataFrameHeader(
- body_len, quiche::SimpleBufferAllocator::Get());
- return std::string(buffer.data(), buffer.size());
- }
- RecordingNetLogObserver net_log_observer_;
- quic::test::QuicFlagSaver saver_;
- const quic::ParsedQuicVersion version_;
- const quic::QuicStreamId client_data_stream_id1_;
- const bool client_headers_include_h2_stream_dependency_;
- // order of destruction of these members matter
- quic::MockClock clock_;
- MockQuicData mock_quic_data_;
- std::unique_ptr<QuicChromiumConnectionHelper> helper_;
- std::unique_ptr<QuicChromiumClientSession> session_;
- std::unique_ptr<QuicChromiumClientSession::Handle> session_handle_;
- std::unique_ptr<QuicProxyClientSocket> sock_;
- std::unique_ptr<TestProxyDelegate> proxy_delegate_;
- raw_ptr<quic::test::MockSendAlgorithm> send_algorithm_;
- scoped_refptr<TestTaskRunner> runner_;
- std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_;
- testing::StrictMock<quic::test::MockQuicConnectionVisitor> visitor_;
- TransportSecurityState transport_security_state_;
- quic::QuicCryptoClientConfig crypto_config_;
- const quic::QuicConnectionId connection_id_;
- QuicTestPacketMaker client_maker_;
- QuicTestPacketMaker server_maker_;
- IPEndPoint peer_addr_;
- quic::test::MockRandom random_generator_{0};
- ProofVerifyDetailsChromium verify_details_;
- MockCryptoClientStreamFactory crypto_client_stream_factory_;
- std::string user_agent_;
- url::SchemeHostPort proxy_endpoint_;
- url::SchemeHostPort destination_endpoint_;
- HttpAuthCache http_auth_cache_;
- std::unique_ptr<MockHostResolverBase> host_resolver_;
- std::unique_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory_;
- TestCompletionCallback read_callback_;
- scoped_refptr<IOBuffer> read_buf_;
- TestCompletionCallback write_callback_;
- quic::test::NoopQpackStreamSenderDelegate noop_qpack_stream_sender_delegate_;
- };
- TEST_P(QuicProxyClientSocketTest, ConnectSendsCorrectRequest) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- ASSERT_FALSE(sock_->IsConnected());
- AssertConnectSucceeds();
- const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
- ASSERT_TRUE(response != nullptr);
- ASSERT_EQ(200, response->headers->response_code());
- // Although the underlying HTTP/3 connection uses TLS and negotiates ALPN, the
- // tunnel itself is a TCP connection to the origin and should not report these
- // values.
- net::SSLInfo ssl_info;
- EXPECT_FALSE(sock_->GetSSLInfo(&ssl_info));
- EXPECT_FALSE(sock_->WasAlpnNegotiated());
- EXPECT_EQ(sock_->GetNegotiatedProtocol(), NextProto::kProtoUnknown);
- }
- TEST_P(QuicProxyClientSocketTest, ProxyDelegateExtraHeaders) {
- proxy_delegate_ = std::make_unique<TestProxyDelegate>();
- // TODO(crbug.com/1206799) Construct `ProxyServer` with plain
- // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
- ProxyServer proxy_server(ProxyServer::SCHEME_HTTPS,
- HostPortPair::FromSchemeHostPort(proxy_endpoint_));
- const char kResponseHeaderName[] = "foo";
- const char kResponseHeaderValue[] = "testing";
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacketWithExtraHeaders(
- packet_number++,
- // Order matters! Keep these alphabetical.
- {{"foo", ProxyServerToProxyUri(proxy_server)},
- {"user-agent", kUserAgent}}));
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerConnectReplyPacketWithExtraHeaders(
- 1, !kFin, {{kResponseHeaderName, kResponseHeaderValue}}));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- ASSERT_FALSE(sock_->IsConnected());
- AssertConnectSucceeds();
- const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
- ASSERT_TRUE(response != nullptr);
- ASSERT_EQ(200, response->headers->response_code());
- proxy_delegate_->VerifyOnTunnelHeadersReceived(
- proxy_server, kResponseHeaderName, kResponseHeaderValue);
- }
- TEST_P(QuicProxyClientSocketTest, ConnectWithAuthRequested) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerConnectAuthReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
- const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
- ASSERT_TRUE(response != nullptr);
- ASSERT_EQ(407, response->headers->response_code());
- }
- TEST_P(QuicProxyClientSocketTest, ConnectWithAuthCredentials) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectAuthRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- // Add auth to cache
- const std::u16string kFoo(u"foo");
- const std::u16string kBar(u"bar");
- http_auth_cache_.Add(
- url::SchemeHostPort(GURL(kProxyUrl)), HttpAuth::AUTH_PROXY, "MyRealm1",
- HttpAuth::AUTH_SCHEME_BASIC, NetworkIsolationKey(),
- "Basic realm=MyRealm1", AuthCredentials(kFoo, kBar), "/");
- AssertConnectSucceeds();
- const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
- ASSERT_TRUE(response != nullptr);
- ASSERT_EQ(200, response->headers->response_code());
- }
- // Tests that a redirect response from a CONNECT fails.
- TEST_P(QuicProxyClientSocketTest, ConnectRedirects) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerConnectRedirectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED);
- const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
- ASSERT_TRUE(response != nullptr);
- const HttpResponseHeaders* headers = response->headers.get();
- ASSERT_EQ(302, headers->response_code());
- ASSERT_TRUE(headers->HasHeader("set-cookie"));
- std::string location;
- ASSERT_TRUE(headers->IsRedirect(&location));
- ASSERT_EQ(location, kRedirectUrl);
- }
- TEST_P(QuicProxyClientSocketTest, ConnectFails) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
- Initialize();
- ASSERT_FALSE(sock_->IsConnected());
- AssertConnectFails(ERR_QUIC_PROTOCOL_ERROR);
- ASSERT_FALSE(sock_->IsConnected());
- }
- TEST_P(QuicProxyClientSocketTest, WasEverUsedReturnsCorrectValue) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- if (VersionUsesHttp3(version_.transport_version))
- EXPECT_TRUE(sock_->WasEverUsed()); // Used due to crypto handshake
- AssertConnectSucceeds();
- EXPECT_TRUE(sock_->WasEverUsed());
- sock_->Disconnect();
- EXPECT_TRUE(sock_->WasEverUsed());
- }
- TEST_P(QuicProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
- Initialize();
- IPEndPoint addr;
- EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
- AssertConnectSucceeds();
- EXPECT_TRUE(sock_->IsConnected());
- EXPECT_THAT(sock_->GetPeerAddress(&addr), IsOk());
- ResumeAndRun();
- EXPECT_FALSE(sock_->IsConnected());
- EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
- sock_->Disconnect();
- EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
- }
- TEST_P(QuicProxyClientSocketTest, IsConnectedAndIdle) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- EXPECT_FALSE(sock_->IsConnectedAndIdle());
- AssertConnectSucceeds();
- EXPECT_TRUE(sock_->IsConnectedAndIdle());
- // The next read is consumed and buffered.
- ResumeAndRun();
- EXPECT_FALSE(sock_->IsConnectedAndIdle());
- AssertSyncReadEquals(kMsg1, kLen1);
- EXPECT_TRUE(sock_->IsConnectedAndIdle());
- }
- TEST_P(QuicProxyClientSocketTest, GetTotalReceivedBytes) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- size_t header_length;
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerConnectReplyPacket(1, !kFin, &header_length));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string data_header = ConstructDataHeader(kLen333);
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(
- 2, data_header + std::string(kMsg333, kLen333)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- EXPECT_EQ(0, sock_->GetTotalReceivedBytes());
- AssertConnectSucceeds();
- if (!VersionUsesHttp3(version_.transport_version)) {
- header_length = 0;
- EXPECT_EQ(0, sock_->GetTotalReceivedBytes());
- } else {
- // HTTP/3 sends and receives HTTP headers on the request stream.
- EXPECT_EQ((int64_t)(header_length), sock_->GetTotalReceivedBytes());
- }
- // The next read is consumed and buffered.
- ResumeAndRun();
- if (!VersionUsesHttp3(version_.transport_version)) {
- EXPECT_EQ(0, sock_->GetTotalReceivedBytes());
- } else {
- // HTTP/3 encodes data with DATA frame. The header is consumed.
- EXPECT_EQ((int64_t)(header_length + data_header.length()),
- sock_->GetTotalReceivedBytes());
- }
- // The payload from the single large data frame will be read across
- // two different reads.
- AssertSyncReadEquals(kMsg33, kLen33);
- EXPECT_EQ((int64_t)(header_length + data_header.length() + kLen33),
- sock_->GetTotalReceivedBytes());
- AssertSyncReadEquals(kMsg3, kLen3);
- EXPECT_EQ((int64_t)(header_length + kLen333 + data_header.length()),
- sock_->GetTotalReceivedBytes());
- }
- TEST_P(QuicProxyClientSocketTest, SetStreamPriority) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- // Despite setting the priority to HIGHEST, the requets initial priority of
- // LOWEST is used.
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructConnectRequestPacket(packet_number++, LOWEST));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- sock_->SetStreamPriority(HIGHEST);
- AssertConnectSucceeds();
- }
- TEST_P(QuicProxyClientSocketTest, WriteSendsDataInDataFrame) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- if (version_.HasIetfQuicFrames()) {
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructAckAndDataPacket(packet_number++, 1, 1,
- {header + std::string(kMsg1, kLen1)}));
- std::string header2 = ConstructDataHeader(kLen2);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructDataPacket(packet_number++,
- {header2 + std::string(kMsg2, kLen2)}));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- } else {
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndDataPacket(packet_number++, 1, 1,
- std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructDataPacket(packet_number++, std::string(kMsg2, kLen2)));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- }
- Initialize();
- AssertConnectSucceeds();
- AssertSyncWriteSucceeds(kMsg1, kLen1);
- AssertSyncWriteSucceeds(kMsg2, kLen2);
- }
- TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
- int write_packet_index = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(write_packet_index++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(write_packet_index++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- std::string header = ConstructDataHeader(kLen1);
- if (!version_.HasIetfQuicFrames()) {
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndDataPacket(write_packet_index++, 1, 1,
- std::string(kMsg1, kLen1)));
- } else {
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructAckAndDataPacket(write_packet_index++, 1, 1,
- {header + std::string(kMsg1, kLen1)}));
- }
- // Expect |kNumDataPackets| data packets, each containing the max possible
- // amount of data.
- int numDataPackets = 3;
- std::string data(numDataPackets * quic::kDefaultMaxPacketSize, 'x');
- quic::QuicStreamOffset offset = kLen1 + header.length();
- if (version_.HasIetfQuicFrames()) {
- numDataPackets++;
- }
- size_t total_data_length = 0;
- for (int i = 0; i < numDataPackets; ++i) {
- size_t max_packet_data_length = GetStreamFrameDataLengthFromPacketLength(
- quic::kDefaultMaxPacketSize, version_, !kIncludeVersion,
- !kIncludeDiversificationNonce, quic::PACKET_8BYTE_CONNECTION_ID,
- quic::PACKET_1BYTE_PACKET_NUMBER, offset);
- if (version_.HasIetfQuicFrames() && i == 0) {
- // 3673 is the data frame length from packet length.
- std::string header2 = ConstructDataHeader(3673);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructDataPacket(
- write_packet_index++,
- {header2 +
- std::string(data.c_str(), max_packet_data_length - 7)}));
- offset += max_packet_data_length - header2.length() - 1;
- } else if (version_.HasIetfQuicFrames() && i == numDataPackets - 1) {
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructDataPacket(write_packet_index++,
- std::string(data.c_str(), 7)));
- offset += 7;
- } else {
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructDataPacket(
- write_packet_index++,
- std::string(data.c_str(), max_packet_data_length)));
- offset += max_packet_data_length;
- }
- if (i != 3) {
- total_data_length += max_packet_data_length;
- }
- }
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(write_packet_index++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- AssertConnectSucceeds();
- // Make a small write. An ACK and STOP_WAITING will be bundled. This prevents
- // ACK and STOP_WAITING from being bundled with the subsequent large write.
- // This allows the test code for computing the size of data sent in each
- // packet to not become too complicated.
- AssertSyncWriteSucceeds(kMsg1, kLen1);
- // Make large write that should be split up
- AssertSyncWriteSucceeds(data.c_str(), total_data_length);
- }
- // ----------- Read
- TEST_P(QuicProxyClientSocketTest, ReadReadsDataInDataFrame) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- }
- TEST_P(QuicProxyClientSocketTest, ReadDataFromBufferedFrames) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header2 = ConstructDataHeader(kLen2);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 3, 3));
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- ResumeAndRun();
- AssertSyncReadEquals(kMsg2, kLen2);
- }
- TEST_P(QuicProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- std::string header2 = ConstructDataHeader(kLen2);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 3, 3));
- Initialize();
- AssertConnectSucceeds();
- // The next two reads are consumed and buffered.
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- AssertSyncReadEquals(kMsg2, kLen2);
- }
- TEST_P(QuicProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen3);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg3, kLen3)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- std::string header2 = ConstructDataHeader(kLen3);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 3, 3));
- Initialize();
- AssertConnectSucceeds();
- // The next two reads are consumed and buffered.
- ResumeAndRun();
- // The payload from two data frames, each with kMsg3 will be combined
- // together into a single read().
- AssertSyncReadEquals(kMsg33, kLen33);
- }
- TEST_P(QuicProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- std::string header2 = ConstructDataHeader(kLen3);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(4, header2 + std::string(kMsg3, kLen3)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 4, 3));
- std::string header3 = ConstructDataHeader(kLen2);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(5, header3 + std::string(kMsg2, kLen2)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 5, 5));
- Initialize();
- AssertConnectSucceeds();
- // The next 4 reads are consumed and buffered.
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- // The payload from two data frames, each with kMsg3 will be combined
- // together into a single read().
- AssertSyncReadEquals(kMsg33, kLen33);
- AssertSyncReadEquals(kMsg2, kLen2);
- }
- TEST_P(QuicProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- std::string header2 = ConstructDataHeader(kLen33);
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
- 3, header2 + std::string(kMsg33, kLen33)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 3, 3));
- Initialize();
- AssertConnectSucceeds();
- // The next 2 reads are consumed and buffered.
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- // The payload from the single large data frame will be read across
- // two different reads.
- AssertSyncReadEquals(kMsg3, kLen3);
- AssertSyncReadEquals(kMsg3, kLen3);
- }
- TEST_P(QuicProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen333);
- mock_quic_data_.AddRead(
- ASYNC,
- ConstructServerDataPacket(2, header + std::string(kMsg333, kLen333)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- AssertConnectSucceeds();
- // The next read is consumed and buffered.
- ResumeAndRun();
- // The payload from the single large data frame will be read across
- // two different reads.
- AssertSyncReadEquals(kMsg33, kLen33);
- // Now attempt to do a read of more data than remains buffered
- scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(kLen33);
- ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, CompletionOnceCallback()));
- ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3));
- ASSERT_TRUE(sock_->IsConnected());
- }
- TEST_P(QuicProxyClientSocketTest, ReadAuthResponseBody) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerConnectAuthReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- std::string header2 = ConstructDataHeader(kLen2);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 3, 3));
- Initialize();
- AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
- // The next two reads are consumed and buffered.
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- AssertSyncReadEquals(kMsg2, kLen2);
- }
- TEST_P(QuicProxyClientSocketTest, ReadErrorResponseBody) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerConnectErrorReplyPacket(1, !kFin));
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- SYNCHRONOUS,
- ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- std::string header2 = ConstructDataHeader(kLen2);
- mock_quic_data_.AddRead(
- SYNCHRONOUS,
- ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 3, 3));
- Initialize();
- AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED);
- }
- // ----------- Reads and Writes
- TEST_P(QuicProxyClientSocketTest, AsyncReadAroundWrite) {
- int write_packet_index = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(write_packet_index++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(write_packet_index++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(write_packet_index++, 2, 1));
- std::string header2 = ConstructDataHeader(kLen2);
- if (version_.HasIetfQuicFrames()) {
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructDataPacket(write_packet_index++,
- {header2 + std::string(kMsg2, kLen2)}));
- } else {
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructDataPacket(write_packet_index++, std::string(kMsg2, kLen2)));
- }
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header3 = ConstructDataHeader(kLen3);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(3, header3 + std::string(kMsg3, kLen3)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(write_packet_index++,
- quic::QUIC_STREAM_CANCELLED, 3, 3));
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- AssertReadStarts(kMsg3, kLen3);
- // Read should block until after the write succeeds.
- AssertSyncWriteSucceeds(kMsg2, kLen2);
- ASSERT_FALSE(read_callback_.have_result());
- ResumeAndRun();
- // Now the read will return.
- AssertReadReturns(kMsg3, kLen3);
- }
- TEST_P(QuicProxyClientSocketTest, AsyncWriteAroundReads) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header2 = ConstructDataHeader(kLen3);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(ASYNC, ERR_IO_PENDING); // Pause
- std::string header3 = ConstructDataHeader(kLen2);
- if (!version_.HasIetfQuicFrames()) {
- mock_quic_data_.AddWrite(
- ASYNC, ConstructDataPacket(packet_number++, std::string(kMsg2, kLen2)));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndDataPacket(packet_number++, 3, 3,
- std::string(kMsg2, kLen2)));
- } else {
- mock_quic_data_.AddWrite(
- ASYNC, ConstructDataPacket(packet_number++,
- {header3 + std::string(kMsg2, kLen2)}));
- mock_quic_data_.AddWrite(
- ASYNC, ConstructAckAndDataPacket(packet_number++, 3, 3,
- header3 + std::string(kMsg2, kLen2)));
- }
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- // Write should block until the next read completes.
- // QuicChromiumClientStream::Handle::WriteStreamData() will only be
- // asynchronous starting with the second time it's called while the UDP socket
- // is write-blocked. Therefore, at least two writes need to be called on
- // |sock_| to get an asynchronous one.
- AssertWriteReturns(kMsg2, kLen2, kLen2);
- AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
- AssertAsyncReadEquals(kMsg3, kLen3);
- ASSERT_FALSE(write_callback_.have_result());
- // Now the write will complete
- ResumeAndRun();
- EXPECT_EQ(kLen2, write_callback_.WaitForResult());
- }
- // ----------- Reading/Writing on Closed socket
- // Reading from an already closed socket should return 0
- TEST_P(QuicProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- ASSERT_FALSE(sock_->IsConnected());
- ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
- ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
- ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
- ASSERT_FALSE(sock_->IsConnectedAndIdle());
- }
- // Read pending when socket is closed should return 0
- TEST_P(QuicProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
- Initialize();
- AssertConnectSucceeds();
- AssertReadStarts(kMsg1, kLen1);
- ResumeAndRun();
- ASSERT_EQ(0, read_callback_.WaitForResult());
- }
- // Reading from a disconnected socket is an error
- TEST_P(QuicProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- AssertConnectSucceeds();
- sock_->Disconnect();
- ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
- sock_->Read(nullptr, 1, CompletionOnceCallback()));
- }
- // Reading data after receiving FIN should return buffered data received before
- // FIN, then 0.
- TEST_P(QuicProxyClientSocketTest, ReadAfterFinReceivedReturnsBufferedData) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataFinPacket(
- 2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
- ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
- sock_->Disconnect();
- ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
- sock_->Read(nullptr, 1, CompletionOnceCallback()));
- }
- // Calling Write() on a closed socket is an error.
- TEST_P(QuicProxyClientSocketTest, WriteOnClosedStream) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- AssertWriteReturns(kMsg1, kLen1, ERR_QUIC_PROTOCOL_ERROR);
- }
- // Calling Write() on a disconnected socket is an error.
- TEST_P(QuicProxyClientSocketTest, WriteOnDisconnectedSocket) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- AssertConnectSucceeds();
- sock_->Disconnect();
- AssertWriteReturns(kMsg1, kLen1, ERR_SOCKET_NOT_CONNECTED);
- }
- // If the socket is closed with a pending Write(), the callback should be called
- // with the same error the session was closed with.
- TEST_P(QuicProxyClientSocketTest, WritePendingOnClose) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(SYNCHRONOUS, ERR_IO_PENDING);
- Initialize();
- AssertConnectSucceeds();
- // QuicChromiumClientStream::Handle::WriteStreamData() will only be
- // asynchronous starting with the second time it's called while the UDP socket
- // is write-blocked. Therefore, at least two writes need to be called on
- // |sock_| to get an asynchronous one.
- AssertWriteReturns(kMsg1, kLen1, kLen1);
- // This second write will be async. This is the pending write that's being
- // tested.
- AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
- // Make sure the write actually starts.
- base::RunLoop().RunUntilIdle();
- session_->CloseSessionOnError(ERR_CONNECTION_CLOSED,
- quic::QUIC_INTERNAL_ERROR,
- quic::ConnectionCloseBehavior::SILENT_CLOSE);
- EXPECT_THAT(write_callback_.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
- }
- TEST_P(QuicProxyClientSocketTest, DisconnectWithWritePending) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(SYNCHRONOUS, ERR_IO_PENDING);
- Initialize();
- AssertConnectSucceeds();
- // QuicChromiumClientStream::Handle::WriteStreamData() will only be
- // asynchronous starting with the second time it's called while the UDP socket
- // is write-blocked. Therefore, at least two writes need to be called on
- // |sock_| to get an asynchronous one.
- AssertWriteReturns(kMsg1, kLen1, kLen1);
- // This second write will be async. This is the pending write that's being
- // tested.
- AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
- // Make sure the write actually starts.
- base::RunLoop().RunUntilIdle();
- sock_->Disconnect();
- EXPECT_FALSE(sock_->IsConnected());
- base::RunLoop().RunUntilIdle();
- EXPECT_FALSE(sock_->IsConnected());
- EXPECT_FALSE(write_callback_.have_result());
- }
- // If the socket is Disconnected with a pending Read(), the callback
- // should not be called.
- TEST_P(QuicProxyClientSocketTest, DisconnectWithReadPending) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_STREAM_CANCELLED, 1, 1));
- Initialize();
- AssertConnectSucceeds();
- EXPECT_TRUE(sock_->IsConnected());
- AssertReadStarts(kMsg1, kLen1);
- sock_->Disconnect();
- EXPECT_FALSE(sock_->IsConnected());
- base::RunLoop().RunUntilIdle();
- EXPECT_FALSE(sock_->IsConnected());
- EXPECT_FALSE(read_callback_.have_result());
- }
- // If the socket is Reset when both a read and write are pending,
- // both should be called back.
- TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePending) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- std::string header = ConstructDataHeader(kLen2);
- if (!version_.HasIetfQuicFrames()) {
- mock_quic_data_.AddWrite(
- ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
- std::string(kMsg2, kLen2)));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_RST_ACKNOWLEDGEMENT, 2, 2));
- } else {
- mock_quic_data_.AddWrite(
- ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
- {header + std::string(kMsg2, kLen2)}));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstOnlyPacket(
- packet_number++, quic::QUIC_STREAM_CANCELLED, 2, 2));
- }
- Initialize();
- AssertConnectSucceeds();
- EXPECT_TRUE(sock_->IsConnected());
- AssertReadStarts(kMsg1, kLen1);
- // Write should block until the next read completes.
- // QuicChromiumClientStream::Handle::WriteStreamData() will only be
- // asynchronous starting with the second time it's called while the UDP socket
- // is write-blocked. Therefore, at least two writes need to be called on
- // |sock_| to get an asynchronous one.
- AssertWriteReturns(kMsg2, kLen2, kLen2);
- AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
- ResumeAndRun();
- EXPECT_TRUE(read_callback_.have_result());
- EXPECT_TRUE(write_callback_.have_result());
- }
- // Makes sure the proxy client socket's source gets the expected NetLog events
- // and only the expected NetLog events (No SpdySession events).
- TEST_P(QuicProxyClientSocketTest, NetLog) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructAckPacket(packet_number++, 2, 1));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
- Initialize();
- AssertConnectSucceeds();
- ResumeAndRun();
- AssertSyncReadEquals(kMsg1, kLen1);
- NetLogSource sock_source = sock_->NetLog().source();
- sock_.reset();
- auto entry_list = net_log_observer_.GetEntriesForSource(sock_source);
- ASSERT_EQ(entry_list.size(), 10u);
- EXPECT_TRUE(
- LogContainsBeginEvent(entry_list, 0, NetLogEventType::SOCKET_ALIVE));
- EXPECT_TRUE(LogContainsEvent(entry_list, 1,
- NetLogEventType::HTTP2_PROXY_CLIENT_SESSION,
- NetLogEventPhase::NONE));
- EXPECT_TRUE(LogContainsBeginEvent(
- entry_list, 2, NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
- EXPECT_TRUE(LogContainsEvent(
- entry_list, 3, NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
- NetLogEventPhase::NONE));
- EXPECT_TRUE(LogContainsEndEvent(
- entry_list, 4, NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
- EXPECT_TRUE(LogContainsBeginEvent(
- entry_list, 5, NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
- EXPECT_TRUE(LogContainsEvent(
- entry_list, 6,
- NetLogEventType::HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
- NetLogEventPhase::NONE));
- EXPECT_TRUE(LogContainsEndEvent(
- entry_list, 7, NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
- EXPECT_TRUE(LogContainsEvent(entry_list, 8,
- NetLogEventType::SOCKET_BYTES_RECEIVED,
- NetLogEventPhase::NONE));
- EXPECT_TRUE(
- LogContainsEndEvent(entry_list, 9, NetLogEventType::SOCKET_ALIVE));
- }
- // A helper class that will delete |sock| when the callback is invoked.
- class DeleteSockCallback : public TestCompletionCallbackBase {
- public:
- explicit DeleteSockCallback(std::unique_ptr<QuicProxyClientSocket>* sock)
- : sock_(sock) {}
- DeleteSockCallback(const DeleteSockCallback&) = delete;
- DeleteSockCallback& operator=(const DeleteSockCallback&) = delete;
- ~DeleteSockCallback() override = default;
- CompletionOnceCallback callback() {
- return base::BindOnce(&DeleteSockCallback::OnComplete,
- base::Unretained(this));
- }
- private:
- void OnComplete(int result) {
- sock_->reset(nullptr);
- SetResult(result);
- }
- raw_ptr<std::unique_ptr<QuicProxyClientSocket>> sock_;
- };
- // If the socket is reset when both a read and write are pending, and the
- // read callback causes the socket to be deleted, the write callback should
- // not be called.
- TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
- int packet_number = 1;
- if (VersionUsesHttp3(version_.transport_version)) {
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructSettingsPacket(packet_number++));
- }
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructConnectRequestPacket(packet_number++));
- mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(
- ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED));
- mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- if (!version_.HasIetfQuicFrames()) {
- mock_quic_data_.AddWrite(
- ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
- std::string(kMsg1, kLen1)));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructAckAndRstPacket(packet_number++,
- quic::QUIC_RST_ACKNOWLEDGEMENT, 2, 2));
- } else {
- std::string header = ConstructDataHeader(kLen1);
- mock_quic_data_.AddWrite(
- ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
- {header + std::string(kMsg1, kLen1)}));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstOnlyPacket(
- packet_number++, quic::QUIC_STREAM_CANCELLED, 2, 2));
- }
- Initialize();
- AssertConnectSucceeds();
- EXPECT_TRUE(sock_->IsConnected());
- DeleteSockCallback read_callback(&sock_);
- scoped_refptr<IOBuffer> read_buf = base::MakeRefCounted<IOBuffer>(kLen1);
- ASSERT_EQ(ERR_IO_PENDING,
- sock_->Read(read_buf.get(), kLen1, read_callback.callback()));
- // QuicChromiumClientStream::Handle::WriteStreamData() will only be
- // asynchronous starting with the second time it's called while the UDP socket
- // is write-blocked. Therefore, at least two writes need to be called on
- // |sock_| to get an asynchronous one.
- AssertWriteReturns(kMsg1, kLen1, kLen1);
- AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
- ResumeAndRun();
- EXPECT_FALSE(sock_.get());
- EXPECT_EQ(0, read_callback.WaitForResult());
- EXPECT_FALSE(write_callback_.have_result());
- }
- INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence,
- QuicProxyClientSocketTest,
- ::testing::ValuesIn(GetTestParams()),
- ::testing::PrintToStringParamName());
- } // namespace net::test
|