net: Make tests that assume NIK features are disabled disable them.

In order to make sure NIKs are set everywhere, and working correctly,
I'm working towards getting all tests passing with partitioning enabled.
This is a small step towards that.

Bug: 1082280
Change-Id: I3549ede3f360c9bd3b906f52cb23f3abe775c7ef
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2585834Reviewed-by: Shivani Sharma <shivanisha@chromium.org>
Commit-Queue: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#836583}

net/http/http_server_properties_unittest.cc

@@ -82,6 +82,8 @@ class HttpServerPropertiesTest : public TestWithTaskEnvironment {
   HttpServerPropertiesTest()
       : TestWithTaskEnvironment(
             base::test::TaskEnvironment::TimeSource::MOCK_TIME),
+        // Many tests assume partitioning is disabled by default.
+        feature_list_(CreateFeatureListWithPartitioningDisabled()),
         test_tick_clock_(GetMockTickClock()),
         impl_(nullptr /* pref_delegate */,
               nullptr /* net_log */,
@@ -96,6 +98,17 @@ class HttpServerPropertiesTest : public TestWithTaskEnvironment {
     network_isolation_key2_ = NetworkIsolationKey(site2, site2);
   }
 
+  // This is a little awkward, but need to create and configure the
+  // ScopedFeatureList before creating the HttpServerProperties.
+  static std::unique_ptr<base::test::ScopedFeatureList>
+  CreateFeatureListWithPartitioningDisabled() {
+    std::unique_ptr<base::test::ScopedFeatureList> feature_list =
+        std::make_unique<base::test::ScopedFeatureList>();
+    feature_list->InitAndDisableFeature(
+        features::kPartitionHttpServerPropertiesByNetworkIsolationKey);
+    return feature_list;
+  }
+
   bool HasAlternativeService(const url::SchemeHostPort& origin,
                              const NetworkIsolationKey& network_isolation_key) {
     const AlternativeServiceInfoVector alternative_service_info_vector =
@@ -121,6 +134,8 @@ class HttpServerPropertiesTest : public TestWithTaskEnvironment {
       const AlternativeService& alternative_service,
       int num_times) {}
 
+  std::unique_ptr<base::test::ScopedFeatureList> feature_list_;
+
   const base::TickClock* test_tick_clock_;
   base::SimpleTestClock test_clock_;
 

net/quic/quic_stream_factory_test.cc

@@ -10882,8 +10882,11 @@ TEST_P(QuicStreamFactoryTest, CryptoConfigCache) {
   const char kUserAgentId[] = "spoon";
 
   base::test::ScopedFeatureList feature_list;
-  feature_list.InitAndEnableFeature(
-      features::kPartitionConnectionsByNetworkIsolationKey);
+  feature_list.InitWithFeatures(
+      // enabled_features
+      {features::kPartitionConnectionsByNetworkIsolationKey},
+      // disabled_features
+      {features::kPartitionHttpServerPropertiesByNetworkIsolationKey});
 
   const SchemefulSite kSite1(GURL("https://foo.test/"));
   const NetworkIsolationKey kNetworkIsolationKey1(kSite1, kSite1);

net/socket/client_socket_pool_unittest.cc

@@ -152,38 +152,30 @@ TEST(ClientSocketPool, GroupIdToString) {
 }
 
 TEST(ClientSocketPool, PartitionConnectionsByNetworkIsolationKeyDisabled) {
-  // Partitioning connections by NetworkIsolationKey is disabled by default, so
-  // test both the explicitly and implicitly disabled cases.
   const SchemefulSite kSiteFoo(GURL("https://foo.com"));
   const SchemefulSite kSiteBar(GURL("https://bar.com"));
-  for (bool explicitly_disabled : {false, true}) {
-    base::test::ScopedFeatureList feature_list;
-    if (explicitly_disabled) {
-      feature_list.InitAndDisableFeature(
-          features::kPartitionConnectionsByNetworkIsolationKey);
-    }
+  base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndDisableFeature(
+      features::kPartitionConnectionsByNetworkIsolationKey);
 
-    ClientSocketPool::GroupId group_id1(HostPortPair("foo", 443),
-                                        ClientSocketPool::SocketType::kSsl,
-                                        PrivacyMode::PRIVACY_MODE_DISABLED,
-                                        NetworkIsolationKey(kSiteFoo, kSiteFoo),
-                                        false /* disable_secure_dns */);
-
-    ClientSocketPool::GroupId group_id2(HostPortPair("foo", 443),
-                                        ClientSocketPool::SocketType::kSsl,
-                                        PrivacyMode::PRIVACY_MODE_DISABLED,
-                                        NetworkIsolationKey(kSiteBar, kSiteBar),
-                                        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());
-  }
+  ClientSocketPool::GroupId group_id1(
+      HostPortPair("foo", 443), ClientSocketPool::SocketType::kSsl,
+      PrivacyMode::PRIVACY_MODE_DISABLED,
+      NetworkIsolationKey(kSiteFoo, kSiteFoo), false /* disable_secure_dns */);
+
+  ClientSocketPool::GroupId group_id2(
+      HostPortPair("foo", 443), ClientSocketPool::SocketType::kSsl,
+      PrivacyMode::PRIVACY_MODE_DISABLED,
+      NetworkIsolationKey(kSiteBar, kSiteBar), 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