diff options
Diffstat (limited to 'chromium/net/quic/quic_network_transaction_unittest.cc')
| -rw-r--r-- | chromium/net/quic/quic_network_transaction_unittest.cc | 229 |
1 files changed, 138 insertions, 91 deletions
diff --git a/chromium/net/quic/quic_network_transaction_unittest.cc b/chromium/net/quic/quic_network_transaction_unittest.cc index 16d29da8157..e826aa68ba3 100644 --- a/chromium/net/quic/quic_network_transaction_unittest.cc +++ b/chromium/net/quic/quic_network_transaction_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -23,7 +23,7 @@ #include "net/base/features.h" #include "net/base/ip_endpoint.h" #include "net/base/mock_network_change_notifier.h" -#include "net/base/network_isolation_key.h" +#include "net/base/network_anonymization_key.h" #include "net/base/schemeful_site.h" #include "net/base/test_completion_callback.h" #include "net/base/test_proxy_delegate.h" @@ -792,14 +792,14 @@ class QuicNetworkTransactionTest void AddQuicAlternateProtocolMapping( MockCryptoClientStream::HandshakeMode handshake_mode, - const NetworkIsolationKey& network_isolation_key = - NetworkIsolationKey()) { + const NetworkAnonymizationKey& network_anonymization_key = + NetworkAnonymizationKey()) { crypto_client_stream_factory_.set_handshake_mode(handshake_mode); url::SchemeHostPort server(request_.url); AlternativeService alternative_service(kProtoQUIC, server.host(), 443); base::Time expiration = base::Time::Now() + base::Days(1); http_server_properties_->SetQuicAlternativeService( - server, network_isolation_key, alternative_service, expiration, + server, network_anonymization_key, alternative_service, expiration, supported_versions_); } @@ -812,37 +812,37 @@ class QuicNetworkTransactionTest alternative.port()); base::Time expiration = base::Time::Now() + base::Days(1); http_server_properties_->SetQuicAlternativeService( - server, NetworkIsolationKey(), alternative_service, expiration, + server, NetworkAnonymizationKey(), alternative_service, expiration, supported_versions_); } void ExpectBrokenAlternateProtocolMapping( - const NetworkIsolationKey& network_isolation_key = - NetworkIsolationKey()) { + const NetworkAnonymizationKey& network_anonymization_key = + NetworkAnonymizationKey()) { const url::SchemeHostPort server(request_.url); const AlternativeServiceInfoVector alternative_service_info_vector = http_server_properties_->GetAlternativeServiceInfos( - server, network_isolation_key); + server, network_anonymization_key); EXPECT_EQ(1u, alternative_service_info_vector.size()); EXPECT_TRUE(http_server_properties_->IsAlternativeServiceBroken( alternative_service_info_vector[0].alternative_service(), - network_isolation_key)); + network_anonymization_key)); } void ExpectQuicAlternateProtocolMapping( - const NetworkIsolationKey& network_isolation_key = - NetworkIsolationKey()) { + const NetworkAnonymizationKey& network_anonymization_key = + NetworkAnonymizationKey()) { const url::SchemeHostPort server(request_.url); const AlternativeServiceInfoVector alternative_service_info_vector = http_server_properties_->GetAlternativeServiceInfos( - server, network_isolation_key); + server, network_anonymization_key); EXPECT_EQ(1u, alternative_service_info_vector.size()); EXPECT_EQ( kProtoQUIC, alternative_service_info_vector[0].alternative_service().protocol); EXPECT_FALSE(http_server_properties_->IsAlternativeServiceBroken( alternative_service_info_vector[0].alternative_service(), - network_isolation_key)); + network_anonymization_key)); } void AddHangingNonAlternateProtocolSocketData() { @@ -1845,12 +1845,12 @@ TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) { 443); base::Time expiration = base::Time::Now() + base::Days(1); http_server_properties_->SetQuicAlternativeService( - server, NetworkIsolationKey(), alternative_service, expiration, + server, NetworkAnonymizationKey(), alternative_service, expiration, {unsupported_version}); AlternativeServiceInfoVector alt_svc_info_vector = http_server_properties_->GetAlternativeServiceInfos( - server, NetworkIsolationKey()); + server, NetworkAnonymizationKey()); EXPECT_EQ(1u, alt_svc_info_vector.size()); EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol); EXPECT_EQ(1u, alt_svc_info_vector[0].advertised_versions().size()); @@ -1913,7 +1913,7 @@ TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) { // Check alternative service list is updated with new versions. alt_svc_info_vector = session_->http_server_properties()->GetAlternativeServiceInfos( - server, NetworkIsolationKey()); + server, NetworkAnonymizationKey()); VerifyQuicVersionsInAlternativeServices(alt_svc_info_vector, supported_versions_); } @@ -1932,7 +1932,7 @@ TEST_P(QuicNetworkTransactionTest, RetryMisdirectedRequest) { 443); base::Time expiration = base::Time::Now() + base::Days(1); http_server_properties_->SetQuicAlternativeService( - server, NetworkIsolationKey(), alternative_service, expiration, + server, NetworkAnonymizationKey(), alternative_service, expiration, supported_versions_); // First try: The alternative job uses QUIC and reports an HTTP 421 @@ -2157,9 +2157,9 @@ TEST_P(QuicNetworkTransactionTest, UseIetfAlternativeServiceForQuic) { SendRequestAndExpectQuicResponse("hello!"); } -// Much like above, but makes sure NetworkIsolationKey is respected. +// Much like above, but makes sure NetworkAnonymizationKey is respected. TEST_P(QuicNetworkTransactionTest, - UseAlternativeServiceForQuicWithNetworkIsolationKey) { + UseAlternativeServiceForQuicWithNetworkAnonymizationKey) { if (version_.AlpnDeferToRFCv1()) { // These versions currently do not support Alt-Svc. return; @@ -2177,8 +2177,11 @@ TEST_P(QuicNetworkTransactionTest, const SchemefulSite kSite1(GURL("https://foo.test/")); const net::NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite1, kSite1); + const SchemefulSite kSite2(GURL("https://bar.test/")); const net::NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2); MockRead http_reads[] = { MockRead("HTTP/1.1 200 OK\r\n"), MockRead(alt_svc_header_.data()), @@ -2188,7 +2191,7 @@ TEST_P(QuicNetworkTransactionTest, AddCertificate(&ssl_data_); - // Request with empty NetworkIsolationKey. + // Request with empty NetworkAnonymizationKey. StaticSocketDataProvider http_data1(http_reads, base::span<MockWrite>()); socket_factory_.AddSocketDataProvider(&http_data1); socket_factory_.AddSSLSocketDataProvider(&ssl_data_); @@ -2235,18 +2238,22 @@ TEST_P(QuicNetworkTransactionTest, CreateSession(); // This is first so that the test fails if alternative service info is - // written with the right NetworkIsolationKey, but always queried with an + // written with the right NetworkAnonymizationKey, but always queried with an // empty one. request_.network_isolation_key = NetworkIsolationKey(); + request_.network_anonymization_key = NetworkAnonymizationKey(); SendRequestAndExpectHttpResponse("hello world"); request_.network_isolation_key = kNetworkIsolationKey1; + request_.network_anonymization_key = kNetworkAnonymizationKey1; SendRequestAndExpectHttpResponse("hello world"); request_.network_isolation_key = kNetworkIsolationKey2; + request_.network_anonymization_key = kNetworkAnonymizationKey2; SendRequestAndExpectHttpResponse("hello world"); - // Only use QUIC when using a NetworkIsolationKey which has been used when + // Only use QUIC when using a NetworkAnonymizationKey which has been used when // alternative service information was received. request_.network_isolation_key = kNetworkIsolationKey1; + request_.network_anonymization_key = kNetworkAnonymizationKey1; SendRequestAndExpectQuicResponse("hello!"); } @@ -2463,13 +2470,13 @@ TEST_P(QuicNetworkTransactionTest, SetAlternativeServiceWithScheme) { url::SchemeHostPort http_server("http", "mail.example.org", 443); url::SchemeHostPort https_server("https", "mail.example.org", 443); // Check alternative service is set for the correct origin. - EXPECT_EQ( - 2u, http_server_properties - ->GetAlternativeServiceInfos(https_server, NetworkIsolationKey()) - .size()); + EXPECT_EQ(2u, http_server_properties + ->GetAlternativeServiceInfos(https_server, + NetworkAnonymizationKey()) + .size()); EXPECT_TRUE( http_server_properties - ->GetAlternativeServiceInfos(http_server, NetworkIsolationKey()) + ->GetAlternativeServiceInfos(http_server, NetworkAnonymizationKey()) .empty()); } @@ -2506,10 +2513,10 @@ TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) { const url::SchemeHostPort https_server(request_.url); // Check alternative service is set. - EXPECT_EQ( - 2u, http_server_properties - ->GetAlternativeServiceInfos(https_server, NetworkIsolationKey()) - .size()); + EXPECT_EQ(2u, http_server_properties + ->GetAlternativeServiceInfos(https_server, + NetworkAnonymizationKey()) + .size()); // Send http request to the same origin but with diffrent scheme, should not // use QUIC. @@ -2579,7 +2586,7 @@ TEST_P(QuicNetworkTransactionTest, const url::SchemeHostPort https_server(request_.url); const AlternativeServiceInfoVector alt_svc_info_vector = session_->http_server_properties()->GetAlternativeServiceInfos( - https_server, NetworkIsolationKey()); + https_server, NetworkAnonymizationKey()); VerifyQuicVersionsInAlternativeServices(alt_svc_info_vector, supported_versions_); } @@ -2971,14 +2978,16 @@ TEST_P( const SchemefulSite kSite1(GURL("https://foo.test/")); const net::NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite1, kSite1); const SchemefulSite kSite2(GURL("https://bar.test/")); const net::NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2); base::test::ScopedFeatureList feature_list; feature_list.InitWithFeatures( // enabled_features {features::kPartitionHttpServerPropertiesByNetworkIsolationKey, - // Need to partition connections by NetworkIsolationKey for + // Need to partition connections by NetworkAnonymizationKey for // QuicSessionAliasKey to include NetworkIsolationKeys. features::kPartitionConnectionsByNetworkIsolationKey}, // disabled_features @@ -3056,11 +3065,14 @@ TEST_P( // QUIC connection requires handshake to be confirmed and sends CHLO to the // peer. AddQuicAlternateProtocolMapping( - MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, kNetworkIsolationKey1); + MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, + kNetworkAnonymizationKey1); AddQuicAlternateProtocolMapping( - MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, kNetworkIsolationKey2); + MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, + kNetworkAnonymizationKey2); request_.network_isolation_key = kNetworkIsolationKey1; + request_.network_anonymization_key = kNetworkAnonymizationKey1; HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); TestCompletionCallback callback; int rv = trans.Start(&request_, callback.callback(), net_log_with_source_); @@ -3080,8 +3092,8 @@ TEST_P( // The second connection hasn't finish handshake, verify that QUIC is not // marked as broken. - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); // Explicitly confirm the handshake on the second connection. crypto_client_stream_factory_.last_stream() ->NotifySessionOneRttKeyAvailable(); @@ -3090,16 +3102,16 @@ TEST_P( base::RunLoop().RunUntilIdle(); // Verify that QUIC is marked as broken for kNetworkIsolationKey1 only. - ExpectBrokenAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectBrokenAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); // Deliver a message to notify the new network becomes default, the previous // brokenness will be clear as the brokenness is bond with old default // network. scoped_mock_change_notifier_->mock_network_change_notifier() ->NotifyNetworkMadeDefault(kNewNetworkForTests); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); ASSERT_TRUE(quic_data2.AllReadDataConsumed()); ASSERT_TRUE(quic_data2.AllWriteDataConsumed()); @@ -3686,7 +3698,7 @@ TEST_P(QuicNetworkTransactionTest, ASSERT_TRUE(http_data.AllReadDataConsumed()); } -// Much like above test, but verifies that NetworkIsolationKey is respected. +// Much like above test, but verifies that NetworkAnonymizationKey is respected. TEST_P(QuicNetworkTransactionTest, ProtocolErrorAfterHandshakeConfirmedThenBrokenWithNetworkIsolationKey) { if (version_.AlpnDeferToRFCv1()) { @@ -3695,8 +3707,10 @@ TEST_P(QuicNetworkTransactionTest, } const SchemefulSite kSite1(GURL("https://foo.test/")); const net::NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite1, kSite1); const SchemefulSite kSite2(GURL("https://bar.test/")); const net::NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2); base::test::ScopedFeatureList feature_list; feature_list.InitWithFeatures( @@ -3772,13 +3786,14 @@ TEST_P(QuicNetworkTransactionTest, CreateSession(); AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT, - kNetworkIsolationKey1); + kNetworkAnonymizationKey1); AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT, - kNetworkIsolationKey2); + kNetworkAnonymizationKey2); HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get()); TestCompletionCallback callback; request_.network_isolation_key = kNetworkIsolationKey1; + request_.network_anonymization_key = kNetworkAnonymizationKey1; int rv = trans.Start(&request_, callback.callback(), net_log_with_source_); EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); @@ -3806,19 +3821,21 @@ TEST_P(QuicNetworkTransactionTest, // The alternative service shouldhave been marked as broken under // kNetworkIsolationKey1 but not kNetworkIsolationKey2. - ExpectBrokenAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectBrokenAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); // Subsequent requests using kNetworkIsolationKey1 should not use QUIC. AddHttpDataAndRunRequest(); // Requests using other NetworkIsolationKeys can still use QUIC. request_.network_isolation_key = kNetworkIsolationKey2; + request_.network_anonymization_key = kNetworkAnonymizationKey2; + AddQuicDataAndRunRequest(); // The last two requests should not have changed the alternative service // mappings. - ExpectBrokenAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectBrokenAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); } // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC @@ -3990,11 +4007,11 @@ TEST_P(QuicNetworkTransactionTest, RemoteAltSvcWorkingWhileLocalAltSvcBroken) { remote_alternative, expiration, context_.params()->supported_versions)); http_server_properties_->SetAlternativeServices(url::SchemeHostPort(origin1), - NetworkIsolationKey(), + NetworkAnonymizationKey(), alternative_services); - http_server_properties_->MarkAlternativeServiceBroken(local_alternative, - NetworkIsolationKey()); + http_server_properties_->MarkAlternativeServiceBroken( + local_alternative, NetworkAnonymizationKey()); SendRequestAndExpectQuicResponse("hello!"); } @@ -4046,11 +4063,11 @@ TEST_P(QuicNetworkTransactionTest, BrokenAlternativeOnlyRecordedOnce) { local_alternative, expiration, context_.params()->supported_versions)); http_server_properties_->SetAlternativeServices(url::SchemeHostPort(origin1), - NetworkIsolationKey(), + NetworkAnonymizationKey(), alternative_services); - http_server_properties_->MarkAlternativeServiceBroken(local_alternative, - NetworkIsolationKey()); + http_server_properties_->MarkAlternativeServiceBroken( + local_alternative, NetworkAnonymizationKey()); SendRequestAndExpectHttpResponse("hello world"); @@ -4174,13 +4191,13 @@ TEST_P(QuicNetworkTransactionTest, base::Time expiration = base::Time::Now() + base::Days(1); AlternativeService alternative1(kProtoQUIC, origin1.host(), 443); http_server_properties_->SetQuicAlternativeService( - url::SchemeHostPort(origin1), NetworkIsolationKey(), alternative1, + url::SchemeHostPort(origin1), NetworkAnonymizationKey(), alternative1, expiration, supported_versions_); // Set up alternative service for |origin2|. AlternativeService alternative2(kProtoQUIC, origin2.host(), 443); http_server_properties_->SetQuicAlternativeService( - url::SchemeHostPort(origin2), NetworkIsolationKey(), alternative2, + url::SchemeHostPort(origin2), NetworkAnonymizationKey(), alternative2, expiration, supported_versions_); // First request opens connection to |destination1| @@ -4193,10 +4210,10 @@ TEST_P(QuicNetworkTransactionTest, request_.url = origin2; SendRequestAndExpectHttpResponse("hello world"); EXPECT_FALSE(http_server_properties_->IsAlternativeServiceBroken( - alternative1, NetworkIsolationKey())) + alternative1, NetworkAnonymizationKey())) << alternative1.ToString(); EXPECT_TRUE(http_server_properties_->IsAlternativeServiceBroken( - alternative2, NetworkIsolationKey())) + alternative2, NetworkAnonymizationKey())) << alternative2.ToString(); // The third request should use a new TCP connection, not the broken @@ -4390,7 +4407,7 @@ TEST_P(QuicNetworkTransactionTest, PoolByOrigin) { AlternativeService alternative_service(kProtoQUIC, destination1, 443); base::Time expiration = base::Time::Now() + base::Days(1); http_server_properties_->SetQuicAlternativeService( - server, NetworkIsolationKey(), alternative_service, expiration, + server, NetworkAnonymizationKey(), alternative_service, expiration, supported_versions_); // First request opens connection to |destination1| // with quic::QuicServerId.host() == kDefaultServerHostName. @@ -4399,7 +4416,7 @@ TEST_P(QuicNetworkTransactionTest, PoolByOrigin) { // Set up alternative service entry to a different destination. alternative_service = AlternativeService(kProtoQUIC, destination2, 443); http_server_properties_->SetQuicAlternativeService( - server, NetworkIsolationKey(), alternative_service, expiration, + server, NetworkAnonymizationKey(), alternative_service, expiration, supported_versions_); // Second request pools to existing connection with same quic::QuicServerId, // even though alternative service destination is different. @@ -4486,8 +4503,8 @@ TEST_P(QuicNetworkTransactionTest, PoolByDestination) { AlternativeService alternative_service1(kProtoQUIC, destination1, 443); base::Time expiration = base::Time::Now() + base::Days(1); http_server_properties_->SetQuicAlternativeService( - url::SchemeHostPort(origin1), NetworkIsolationKey(), alternative_service1, - expiration, supported_versions_); + url::SchemeHostPort(origin1), NetworkAnonymizationKey(), + alternative_service1, expiration, supported_versions_); // Set up multiple alternative service entries for |origin2|, // the first one with a different destination as for |origin1|, @@ -4504,7 +4521,7 @@ TEST_P(QuicNetworkTransactionTest, PoolByDestination) { alternative_service1, expiration, context_.params()->supported_versions)); http_server_properties_->SetAlternativeServices(url::SchemeHostPort(origin2), - NetworkIsolationKey(), + NetworkAnonymizationKey(), alternative_services); // First request opens connection to |destination1| // with quic::QuicServerId.host() == origin1.host(). @@ -4659,7 +4676,7 @@ TEST_P(QuicNetworkTransactionTest, AlternativeServiceDifferentPort) { url::SchemeHostPort http_server("https", kDefaultServerHostName, 443); AlternativeServiceInfoVector alternative_service_info_vector = http_server_properties_->GetAlternativeServiceInfos( - http_server, NetworkIsolationKey()); + http_server, NetworkAnonymizationKey()); ASSERT_EQ(1u, alternative_service_info_vector.size()); const AlternativeService alternative_service = alternative_service_info_vector[0].alternative_service(); @@ -4716,9 +4733,9 @@ TEST_P(QuicNetworkTransactionTest, ConfirmAlternativeService) { AlternativeService alternative_service(kProtoQUIC, HostPortPair::FromURL(request_.url)); http_server_properties_->MarkAlternativeServiceRecentlyBroken( - alternative_service, NetworkIsolationKey()); + alternative_service, NetworkAnonymizationKey()); EXPECT_TRUE(http_server_properties_->WasAlternativeServiceRecentlyBroken( - alternative_service, NetworkIsolationKey())); + alternative_service, NetworkAnonymizationKey())); SendRequestAndExpectHttpResponse("hello world"); SendRequestAndExpectQuicResponse("hello!"); @@ -4726,10 +4743,10 @@ TEST_P(QuicNetworkTransactionTest, ConfirmAlternativeService) { mock_quic_data.Resume(); EXPECT_FALSE(http_server_properties_->WasAlternativeServiceRecentlyBroken( - alternative_service, NetworkIsolationKey())); + alternative_service, NetworkAnonymizationKey())); EXPECT_NE(nullptr, http_server_properties_->GetServerNetworkStats( url::SchemeHostPort("https", request_.url.host(), 443), - NetworkIsolationKey())); + NetworkAnonymizationKey())); } TEST_P(QuicNetworkTransactionTest, @@ -4740,8 +4757,10 @@ TEST_P(QuicNetworkTransactionTest, } const SchemefulSite kSite1(GURL("https://foo.test/")); const net::NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite1, kSite1); const SchemefulSite kSite2(GURL("https://bar.test/")); const net::NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2); base::test::ScopedFeatureList feature_list; feature_list.InitWithFeatures( @@ -4796,30 +4815,31 @@ TEST_P(QuicNetworkTransactionTest, AlternativeService alternative_service(kProtoQUIC, HostPortPair::FromURL(request_.url)); http_server_properties_->MarkAlternativeServiceRecentlyBroken( - alternative_service, kNetworkIsolationKey1); + alternative_service, kNetworkAnonymizationKey1); http_server_properties_->MarkAlternativeServiceRecentlyBroken( - alternative_service, kNetworkIsolationKey2); + alternative_service, kNetworkAnonymizationKey2); EXPECT_TRUE(http_server_properties_->WasAlternativeServiceRecentlyBroken( - alternative_service, kNetworkIsolationKey1)); + alternative_service, kNetworkAnonymizationKey1)); EXPECT_TRUE(http_server_properties_->WasAlternativeServiceRecentlyBroken( - alternative_service, kNetworkIsolationKey2)); + alternative_service, kNetworkAnonymizationKey2)); request_.network_isolation_key = kNetworkIsolationKey1; + request_.network_anonymization_key = kNetworkAnonymizationKey1; SendRequestAndExpectHttpResponse("hello world"); SendRequestAndExpectQuicResponse("hello!"); mock_quic_data.Resume(); EXPECT_FALSE(http_server_properties_->WasAlternativeServiceRecentlyBroken( - alternative_service, kNetworkIsolationKey1)); + alternative_service, kNetworkAnonymizationKey1)); EXPECT_NE(nullptr, http_server_properties_->GetServerNetworkStats( url::SchemeHostPort("https", request_.url.host(), 443), - kNetworkIsolationKey1)); + kNetworkAnonymizationKey1)); EXPECT_TRUE(http_server_properties_->WasAlternativeServiceRecentlyBroken( - alternative_service, kNetworkIsolationKey2)); + alternative_service, kNetworkAnonymizationKey2)); EXPECT_EQ(nullptr, http_server_properties_->GetServerNetworkStats( url::SchemeHostPort("https", request_.url.host(), 443), - kNetworkIsolationKey2)); + kNetworkAnonymizationKey2)); } TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuicForHttps) { @@ -4982,7 +5002,7 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) { EXPECT_EQ(nullptr, http_server_properties_->GetServerNetworkStats( url::SchemeHostPort("https", request_.url.host(), 443), - NetworkIsolationKey())); + NetworkAnonymizationKey())); } TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) { @@ -5647,8 +5667,10 @@ TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolWithNetworkIsolationKey) { const SchemefulSite kSite1(GURL("https://foo.test/")); const net::NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite1, kSite1); const SchemefulSite kSite2(GURL("https://bar.test/")); const net::NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2); base::test::ScopedFeatureList feature_list; feature_list.InitWithFeatures( @@ -5684,14 +5706,17 @@ TEST_P(QuicNetworkTransactionTest, CreateSession(); AddQuicAlternateProtocolMapping( - MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, kNetworkIsolationKey1); + MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, + kNetworkAnonymizationKey1); AddQuicAlternateProtocolMapping( - MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, kNetworkIsolationKey2); + MockCryptoClientStream::COLD_START_WITH_CHLO_SENT, + kNetworkAnonymizationKey2); request_.network_isolation_key = kNetworkIsolationKey1; + request_.network_anonymization_key = kNetworkAnonymizationKey1; SendRequestAndExpectHttpResponse("hello from http"); - ExpectBrokenAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectBrokenAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); } TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) { @@ -5983,8 +6008,10 @@ TEST_P(QuicNetworkTransactionTest, const SchemefulSite kSite1(GURL("https://foo.test/")); const net::NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite1, kSite1); const SchemefulSite kSite2(GURL("https://bar.test/")); const net::NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2); + const net::NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2); // Alternate-protocol job MockRead quic_reads[] = { @@ -6010,28 +6037,31 @@ TEST_P(QuicNetworkTransactionTest, CreateSession(); AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT, - kNetworkIsolationKey1); + kNetworkAnonymizationKey1); AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT, - kNetworkIsolationKey2); + kNetworkAnonymizationKey2); request_.network_isolation_key = kNetworkIsolationKey1; + request_.network_anonymization_key = kNetworkAnonymizationKey1; SendRequestAndExpectHttpResponse("hello from http"); EXPECT_TRUE(quic_data.AllReadDataConsumed()); EXPECT_TRUE(quic_data.AllWriteDataConsumed()); - ExpectBrokenAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectBrokenAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); // Subsequent requests using kNetworkIsolationKey1 should not use QUIC. AddHttpDataAndRunRequest(); // Requests using other NetworkIsolationKeys can still use QUIC. request_.network_isolation_key = kNetworkIsolationKey2; + request_.network_anonymization_key = kNetworkAnonymizationKey2; + AddQuicDataAndRunRequest(); // The last two requests should not have changed the alternative service // mappings. - ExpectBrokenAlternateProtocolMapping(kNetworkIsolationKey1); - ExpectQuicAlternateProtocolMapping(kNetworkIsolationKey2); + ExpectBrokenAlternateProtocolMapping(kNetworkAnonymizationKey1); + ExpectQuicAlternateProtocolMapping(kNetworkAnonymizationKey2); } TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolOnConnectFailure) { @@ -6766,14 +6796,23 @@ TEST_P(QuicNetworkTransactionTest, QuicServerPushRespectsNetworkIsolationKey) { NetworkIsolationKey::CreateTransient(); NetworkIsolationKey network_isolation_key2 = NetworkIsolationKey::CreateTransient(); + NetworkAnonymizationKey network_anonymization_key1 = + net::NetworkAnonymizationKey::CreateFromNetworkIsolationKey( + network_isolation_key1); + NetworkAnonymizationKey network_anonymization_key2 = + net::NetworkAnonymizationKey::CreateFromNetworkIsolationKey( + network_isolation_key2); // Creates the first QUIC session, and triggers the first push. request_.network_isolation_key = network_isolation_key1; + request_.network_anonymization_key = network_anonymization_key1; + SendRequestAndExpectQuicResponse("hello1"); // Use a different NIK, which creates another QUIC session, triggering a // second push, request_.network_isolation_key = network_isolation_key2; + request_.network_anonymization_key = network_anonymization_key2; SendRequestAndExpectQuicResponse("hello2"); // Use the second NIK again, should receive the push body from the second @@ -6784,6 +6823,7 @@ TEST_P(QuicNetworkTransactionTest, QuicServerPushRespectsNetworkIsolationKey) { // Use the first NIK again, should receive the push body from the first // session. request_.network_isolation_key = network_isolation_key1; + request_.network_anonymization_key = network_anonymization_key1; SendRequestAndExpectQuicResponse("and hello1"); } @@ -7100,7 +7140,7 @@ class QuicNetworkTransactionWithDestinationTest AlternativeService alternative_service(kProtoQUIC, destination); base::Time expiration = base::Time::Now() + base::Days(1); http_server_properties_.SetQuicAlternativeService( - url::SchemeHostPort("https", origin, 443), NetworkIsolationKey(), + url::SchemeHostPort("https", origin, 443), NetworkAnonymizationKey(), alternative_service, expiration, supported_versions_); } @@ -8945,13 +8985,15 @@ TEST_P(QuicNetworkTransactionTest, QuicServerPushUpdatesPriority) { EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed()); } -// Test that NetworkIsolationKey is respected by QUIC connections, when +// Test that NetworkAnonymizationKey is respected by QUIC connections, when // kPartitionConnectionsByNetworkIsolationKey is enabled. TEST_P(QuicNetworkTransactionTest, NetworkIsolation) { const SchemefulSite kSite1(GURL("http://origin1/")); const SchemefulSite kSite2(GURL("http://origin2/")); NetworkIsolationKey network_isolation_key1(kSite1, kSite1); NetworkIsolationKey network_isolation_key2(kSite2, kSite2); + NetworkAnonymizationKey network_anonymization_key1(kSite1, kSite1); + NetworkAnonymizationKey network_anonymization_key2(kSite2, kSite2); context_.params()->origins_to_force_quic_on.insert( HostPortPair::FromString("mail.example.org:443")); @@ -9199,6 +9241,7 @@ TEST_P(QuicNetworkTransactionTest, NetworkIsolation) { request1.traffic_annotation = net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); request1.network_isolation_key = network_isolation_key1; + request1.network_anonymization_key = network_anonymization_key1; HttpNetworkTransaction trans1(LOWEST, session_.get()); int rv = trans1.Start(&request1, callback.callback(), NetLogWithSource()); EXPECT_THAT(callback.GetResult(rv), IsOk()); @@ -9212,6 +9255,7 @@ TEST_P(QuicNetworkTransactionTest, NetworkIsolation) { request2.traffic_annotation = net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); request2.network_isolation_key = network_isolation_key2; + request2.network_anonymization_key = network_anonymization_key2; HttpNetworkTransaction trans2(LOWEST, session_.get()); rv = trans2.Start(&request2, callback.callback(), NetLogWithSource()); EXPECT_THAT(callback.GetResult(rv), IsOk()); @@ -9225,6 +9269,8 @@ TEST_P(QuicNetworkTransactionTest, NetworkIsolation) { request3.traffic_annotation = net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS); request3.network_isolation_key = network_isolation_key1; + request3.network_anonymization_key = network_anonymization_key1; + HttpNetworkTransaction trans3(LOWEST, session_.get()); rv = trans3.Start(&request3, callback.callback(), NetLogWithSource()); EXPECT_THAT(callback.GetResult(rv), IsOk()); @@ -9341,6 +9387,7 @@ TEST_P(QuicNetworkTransactionTest, NetworkIsolationTunnel) { HttpRequestInfo request2; const SchemefulSite kSite1(GURL("http://origin1/")); request_.network_isolation_key = NetworkIsolationKey(kSite1, kSite1); + request_.network_anonymization_key = NetworkAnonymizationKey(kSite1, kSite1); HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session_.get()); RunTransaction(&trans2); CheckResponseData(&trans2, "0123456789"); @@ -9551,7 +9598,7 @@ TEST_P(QuicNetworkTransactionTest, ServerNetworkStats stats1; stats1.srtt = base::Microseconds(10); http_server_properties_->SetServerNetworkStats( - url::SchemeHostPort(request_.url), NetworkIsolationKey(), stats1); + url::SchemeHostPort(request_.url), NetworkAnonymizationKey(), stats1); // Set up request. request_.method = "POST"; |