| // Copyright 2019 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/socket/client_socket_pool.h" |
| |
| #include <string> |
| #include <vector> |
| |
| #include "base/test/scoped_feature_list.h" |
| #include "net/base/features.h" |
| #include "net/base/host_port_pair.h" |
| #include "net/base/network_isolation_key.h" |
| #include "net/base/privacy_mode.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "url/gurl.h" |
| #include "url/origin.h" |
| |
| namespace net { |
| |
| namespace { |
| |
| // TODO(950069): Add testing for frame_origin in NetworkIsolationKey |
| // using kAppendInitiatingFrameOriginToNetworkIsolationKey. |
| |
| TEST(ClientSocketPool, GroupIdOperators) { |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndEnableFeature( |
| features::kPartitionConnectionsByNetworkIsolationKey); |
| |
| // Each of these lists is in "<" order, as defined by Group::operator< on the |
| // corresponding field. |
| |
| // HostPortPair::operator< compares port before host. |
| const HostPortPair kHostPortPairs[] = { |
| {"b", 79}, {"a", 80}, {"b", 80}, {"c", 81}, {"a", 443}, {"c", 443}, |
| }; |
| |
| const ClientSocketPool::SocketType kSocketTypes[] = { |
| ClientSocketPool::SocketType::kHttp, |
| ClientSocketPool::SocketType::kSsl, |
| }; |
| |
| const PrivacyMode kPrivacyModes[] = { |
| PrivacyMode::PRIVACY_MODE_DISABLED, |
| PrivacyMode::PRIVACY_MODE_ENABLED, |
| }; |
| |
| const auto kOriginA = url::Origin::Create(GURL("http://a.test/")); |
| const auto kOriginB = url::Origin::Create(GURL("http://b.test/")); |
| const NetworkIsolationKey kNetworkIsolationKeys[] = { |
| NetworkIsolationKey(kOriginA, kOriginA), |
| NetworkIsolationKey(kOriginB, kOriginB), |
| }; |
| |
| const bool kDisableSecureDnsValues[] = {false, true}; |
| |
| // All previously created |group_ids|. They should all be less than the |
| // current group under consideration. |
| std::vector<ClientSocketPool::GroupId> group_ids; |
| |
| // Iterate through all sets of group ids, from least to greatest. |
| for (const auto& host_port_pair : kHostPortPairs) { |
| SCOPED_TRACE(host_port_pair.ToString()); |
| for (const auto& socket_type : kSocketTypes) { |
| SCOPED_TRACE(static_cast<int>(socket_type)); |
| for (const auto& privacy_mode : kPrivacyModes) { |
| SCOPED_TRACE(privacy_mode); |
| for (const auto& network_isolation_key : kNetworkIsolationKeys) { |
| SCOPED_TRACE(network_isolation_key.ToString()); |
| for (const auto& disable_secure_dns : kDisableSecureDnsValues) { |
| ClientSocketPool::GroupId group_id( |
| host_port_pair, socket_type, privacy_mode, |
| network_isolation_key, disable_secure_dns); |
| for (const auto& lower_group_id : group_ids) { |
| EXPECT_FALSE(lower_group_id == group_id); |
| EXPECT_TRUE(lower_group_id < group_id); |
| EXPECT_FALSE(group_id < lower_group_id); |
| } |
| |
| group_ids.push_back(group_id); |
| |
| // Compare |group_id| to itself. Use two different copies of |
| // |group_id|'s value, since to protect against bugs where an object |
| // only equals itself. |
| EXPECT_TRUE(group_ids.back() == group_id); |
| EXPECT_FALSE(group_ids.back() < group_id); |
| EXPECT_FALSE(group_id < group_ids.back()); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| TEST(ClientSocketPool, GroupIdToString) { |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitWithFeatures( |
| {features::kPartitionConnectionsByNetworkIsolationKey}, |
| {features::kAppendFrameOriginToNetworkIsolationKey}); |
| |
| EXPECT_EQ("foo:80 <null>", |
| ClientSocketPool::GroupId( |
| HostPortPair("foo", 80), ClientSocketPool::SocketType::kHttp, |
| PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(), |
| false /* disable_secure_dns */) |
| .ToString()); |
| EXPECT_EQ("bar:443 <null>", |
| ClientSocketPool::GroupId( |
| HostPortPair("bar", 443), ClientSocketPool::SocketType::kHttp, |
| PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(), |
| false /* disable_secure_dns */) |
| .ToString()); |
| EXPECT_EQ("pm/bar:80 <null>", |
| ClientSocketPool::GroupId( |
| HostPortPair("bar", 80), ClientSocketPool::SocketType::kHttp, |
| PrivacyMode::PRIVACY_MODE_ENABLED, NetworkIsolationKey(), |
| false /* disable_secure_dns */) |
| .ToString()); |
| |
| EXPECT_EQ("ssl/foo:80 <null>", |
| ClientSocketPool::GroupId( |
| HostPortPair("foo", 80), ClientSocketPool::SocketType::kSsl, |
| PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(), |
| false /* disable_secure_dns */) |
| .ToString()); |
| EXPECT_EQ("ssl/bar:443 <null>", |
| ClientSocketPool::GroupId( |
| HostPortPair("bar", 443), ClientSocketPool::SocketType::kSsl, |
| PrivacyMode::PRIVACY_MODE_DISABLED, NetworkIsolationKey(), |
| false /* disable_secure_dns */) |
| .ToString()); |
| EXPECT_EQ("pm/ssl/bar:80 <null>", |
| ClientSocketPool::GroupId( |
| HostPortPair("bar", 80), ClientSocketPool::SocketType::kSsl, |
| PrivacyMode::PRIVACY_MODE_ENABLED, NetworkIsolationKey(), |
| false /* disable_secure_dns */) |
| .ToString()); |
| |
| EXPECT_EQ( |
| "ssl/foo:443 <https://foo.com>", |
| ClientSocketPool::GroupId( |
| HostPortPair("foo", 443), ClientSocketPool::SocketType::kSsl, |
| PrivacyMode::PRIVACY_MODE_DISABLED, |
| NetworkIsolationKey(url::Origin::Create(GURL("https://foo.com")), |
| url::Origin::Create(GURL("https://foo.com"))), |
| false /* disable_secure_dns */) |
| .ToString()); |
| |
| EXPECT_EQ("dsd/pm/ssl/bar:80 <null>", |
| ClientSocketPool::GroupId( |
| HostPortPair("bar", 80), ClientSocketPool::SocketType::kSsl, |
| PrivacyMode::PRIVACY_MODE_ENABLED, NetworkIsolationKey(), |
| true /* disable_secure_dns */) |
| .ToString()); |
| } |
| |
| TEST(ClientSocketPool, PartitionConnectionsByNetworkIsolationKeyDisabled) { |
| // Partitioning connections by NetworkIsolationKey is disabled by default, so |
| // test both the explicitly and implicitly disabled cases. |
| const auto kOriginFoo = url::Origin::Create(GURL("https://foo.com")); |
| const auto kOriginBar = url::Origin::Create(GURL("https://bar.com")); |
| for (bool explicitly_disabled : {false, true}) { |
| base::test::ScopedFeatureList feature_list; |
| if (explicitly_disabled) { |
| feature_list.InitAndDisableFeature( |
| features::kPartitionConnectionsByNetworkIsolationKey); |
| } |
| |
| ClientSocketPool::GroupId group_id1( |
| HostPortPair("foo", 443), ClientSocketPool::SocketType::kSsl, |
| PrivacyMode::PRIVACY_MODE_DISABLED, |
| NetworkIsolationKey(kOriginFoo, kOriginFoo), |
| false /* disable_secure_dns */); |
| |
| ClientSocketPool::GroupId group_id2( |
| HostPortPair("foo", 443), ClientSocketPool::SocketType::kSsl, |
| PrivacyMode::PRIVACY_MODE_DISABLED, |
| NetworkIsolationKey(kOriginBar, kOriginBar), |
| false /* disable_secure_dns */); |
| |
| EXPECT_FALSE(group_id1.network_isolation_key().IsFullyPopulated()); |
| EXPECT_FALSE(group_id2.network_isolation_key().IsFullyPopulated()); |
| EXPECT_EQ(group_id1.network_isolation_key(), |
| group_id2.network_isolation_key()); |
| EXPECT_EQ(group_id1, group_id2); |
| |
| EXPECT_EQ("ssl/foo:443", group_id1.ToString()); |
| EXPECT_EQ("ssl/foo:443", group_id2.ToString()); |
| } |
| } |
| |
| } // namespace |
| |
| } // namespace net |