Google Git
Sign in
chromium / chromium / src / lkgr / . / net / base / features.cc
blob: 567521efdfb20aa56722b9c788236173fcfdec17 [file] [log] [blame]
Avi Drissman64595482022-09-14 20:52:29[diff] [blame]1// Copyright 2018 The Chromium Authors
Mythri Alle030e8f892018-10-09 14:58:17[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/base/features.h"
Daniel McArdle4705fd32020-05-18 21:44:14[diff] [blame]6
Tom Van Goethem8f760752025-04-24 01:28:53[diff] [blame]7#include <string>
Daniel McArdle4705fd32020-05-18 21:44:14[diff] [blame]8#include <vector>
9
Olivier Lid1b497c2021-07-21 15:35:27[diff] [blame]10#include "base/feature_list.h"
Matt Muellerc136bf52020-01-07 01:35:41[diff] [blame]11#include "build/build_config.h"
Liza Burakova7ac2b962023-07-11 16:06:27[diff] [blame]12#include "net/base/cronet_buildflags.h"
Matt Mueller8b02b1902023-03-07 00:06:36[diff] [blame]13#include "net/net_buildflags.h"
Mythri Alle030e8f892018-10-09 14:58:17[diff] [blame]14
Ari Chivukula70b4390c2025-05-23 13:12:27[diff] [blame]15#if BUILDFLAG(IS_WIN)
16#include "base/win/windows_version.h"
17#endif
18
Tsuyoshi Horo4f516be2022-06-14 11:53:13[diff] [blame]19namespace net::features {
Mythri Alle030e8f892018-10-09 14:58:17[diff] [blame]20
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]21BASE_FEATURE(kAlpsForHttp2, "AlpsForHttp2", base::FEATURE_ENABLED_BY_DEFAULT);
Bence Békycfb16812021-04-01 21:30:45[diff] [blame]22
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]23BASE_FEATURE(kAvoidH2Reprioritization,
24 "AvoidH2Reprioritization",
25 base::FEATURE_DISABLED_BY_DEFAULT);
Eric Orthfe639c22021-06-25 22:00:55[diff] [blame]26
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]27BASE_FEATURE(kCapReferrerToOriginOnCrossOrigin,
28 "CapReferrerToOriginOnCrossOrigin",
29 base::FEATURE_DISABLED_BY_DEFAULT);
David Van Cleve09c1e8882020-06-24 17:05:50[diff] [blame]30
Kenichi Ishibashi696c6de2024-01-30 00:37:39[diff] [blame]31BASE_FEATURE(kAsyncDns,
32 "AsyncDns",
33#if BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_MAC) || BUILDFLAG(IS_ANDROID) || \
34 BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX)
35 base::FEATURE_ENABLED_BY_DEFAULT
36#else
37 base::FEATURE_DISABLED_BY_DEFAULT
38#endif
39);
40
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]41BASE_FEATURE(kDnsTransactionDynamicTimeouts,
42 "DnsTransactionDynamicTimeouts",
43 base::FEATURE_DISABLED_BY_DEFAULT);
Eric Orth24c8ed842020-10-16 21:23:34[diff] [blame]44
45const base::FeatureParam<double> kDnsTransactionTimeoutMultiplier{
46 &kDnsTransactionDynamicTimeouts, "DnsTransactionTimeoutMultiplier", 7.5};
47
48const base::FeatureParam<base::TimeDelta> kDnsMinTransactionTimeout{
49 &kDnsTransactionDynamicTimeouts, "DnsMinTransactionTimeout",
Peter Kastinge5a38ed2021-10-02 03:06:35[diff] [blame]50 base::Seconds(12)};
Eric Orth24c8ed842020-10-16 21:23:34[diff] [blame]51
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]52BASE_FEATURE(kUseDnsHttpsSvcb,
53 "UseDnsHttpsSvcb",
54 base::FEATURE_ENABLED_BY_DEFAULT);
Eric Orthfe639c22021-06-25 22:00:55[diff] [blame]55
Eric Orthfe639c22021-06-25 22:00:55[diff] [blame]56const base::FeatureParam<bool> kUseDnsHttpsSvcbEnforceSecureResponse{
57 &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbEnforceSecureResponse", false};
58
Eric Orth50f10c12022-04-07 19:48:02[diff] [blame]59const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbInsecureExtraTimeMax{
60 &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbInsecureExtraTimeMax",
Eric Orth4f7ca9f2022-08-23 18:21:52[diff] [blame]61 base::Milliseconds(50)};
Eric Orth50f10c12022-04-07 19:48:02[diff] [blame]62
63const base::FeatureParam<int> kUseDnsHttpsSvcbInsecureExtraTimePercent{
Eric Orth4f7ca9f2022-08-23 18:21:52[diff] [blame]64 &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbInsecureExtraTimePercent", 20};
Eric Orth50f10c12022-04-07 19:48:02[diff] [blame]65
66const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbInsecureExtraTimeMin{
67 &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbInsecureExtraTimeMin",
Eric Orth4f7ca9f2022-08-23 18:21:52[diff] [blame]68 base::Milliseconds(5)};
Eric Orth50f10c12022-04-07 19:48:02[diff] [blame]69
70const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbSecureExtraTimeMax{
Eric Orth4f7ca9f2022-08-23 18:21:52[diff] [blame]71 &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbSecureExtraTimeMax",
72 base::Milliseconds(50)};
Eric Orth50f10c12022-04-07 19:48:02[diff] [blame]73
74const base::FeatureParam<int> kUseDnsHttpsSvcbSecureExtraTimePercent{
Eric Orth4f7ca9f2022-08-23 18:21:52[diff] [blame]75 &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbSecureExtraTimePercent", 20};
Eric Orth50f10c12022-04-07 19:48:02[diff] [blame]76
77const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbSecureExtraTimeMin{
Eric Orth4f7ca9f2022-08-23 18:21:52[diff] [blame]78 &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbSecureExtraTimeMin",
79 base::Milliseconds(5)};
Eric Orth50f10c12022-04-07 19:48:02[diff] [blame]80
Eric Orth0bd8e9952024-01-25 19:08:33[diff] [blame]81BASE_FEATURE(kUseHostResolverCache,
82 "UseHostResolverCache",
83 base::FEATURE_DISABLED_BY_DEFAULT);
84
Kenichi Ishibashi0cddce172024-08-03 00:24:33[diff] [blame]85BASE_FEATURE(kHappyEyeballsV3,
86 "HappyEyeballsV3",
Kenichi Ishibashi1751e602024-04-15 00:53:05[diff] [blame]87 base::FEATURE_DISABLED_BY_DEFAULT);
88
Tsuyoshi Horo9898b302023-07-20 01:26:42[diff] [blame]89const base::FeatureParam<int> kAlternativePortForGloballyReachableCheck{
90 &kUseAlternativePortForGloballyReachableCheck,
91 "AlternativePortForGloballyReachableCheck", 443};
92
93BASE_FEATURE(kUseAlternativePortForGloballyReachableCheck,
94 "UseAlternativePortForGloballyReachableCheck",
95 base::FEATURE_DISABLED_BY_DEFAULT);
96
Kenichi Ishibashiae494c8e2023-10-10 03:43:18[diff] [blame]97BASE_FEATURE(kEnableIPv6ReachabilityOverride,
98 "EnableIPv6ReachabilityOverride",
99 base::FEATURE_DISABLED_BY_DEFAULT);
100
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]101BASE_FEATURE(kEnableTLS13EarlyData,
102 "EnableTLS13EarlyData",
103 base::FEATURE_DISABLED_BY_DEFAULT);
Steven Valdez89a44ea92019-05-01 15:18:49[diff] [blame]104
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]105BASE_FEATURE(kNetworkQualityEstimator,
106 "NetworkQualityEstimator",
107 base::FEATURE_DISABLED_BY_DEFAULT);
Tarun Bansald2ef20c62019-03-12 21:43:30[diff] [blame]108
Yoshisato Yanagisawa506cdef2024-07-16 08:28:48[diff] [blame]109const base::FeatureParam<int> kRecentHTTPThresholdInSeconds{
110 &kNetworkQualityEstimator, "RecentHTTPThresholdInSeconds", -1};
111const base::FeatureParam<int> kRecentTransportThresholdInSeconds{
112 &kNetworkQualityEstimator, "RecentTransportThresholdInSeconds", -1};
113const base::FeatureParam<int> kRecentEndToEndThresholdInSeconds{
114 &kNetworkQualityEstimator, "RecentEndToEndThresholdInSeconds", -1};
Yoshisato Yanagisawa0b2c4362024-07-19 05:51:41[diff] [blame]115const base::FeatureParam<int> kCountNewObservationsReceivedComputeEct{
116 &kNetworkQualityEstimator, "CountNewObservationsReceivedComputeEct", 50};
117const base::FeatureParam<int> kObservationBufferSize{
118 &kNetworkQualityEstimator, "ObservationBufferSize", 300};
119const base::FeatureParam<base::TimeDelta>
120 kEffectiveConnectionTypeRecomputationInterval{
121 &kNetworkQualityEstimator,
122 "EffectiveConnectionTypeRecomputationInterval", base::Seconds(10)};
Yoshisato Yanagisawa506cdef2024-07-16 08:28:48[diff] [blame]123
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]124BASE_FEATURE(kSplitCacheByIncludeCredentials,
125 "SplitCacheByIncludeCredentials",
126 base::FEATURE_DISABLED_BY_DEFAULT);
Arthur Sonzogni54013f22021-09-03 14:57:12[diff] [blame]127
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]128BASE_FEATURE(kSplitCacheByNetworkIsolationKey,
129 "SplitCacheByNetworkIsolationKey",
130 base::FEATURE_DISABLED_BY_DEFAULT);
Josh Karlinf3caee1642018-12-10 22:54:27[diff] [blame]131
Andrew Williams8bea9cb2025-03-13 15:08:56[diff] [blame]132// Note: Use of this feature is gated on the HTTP cache itself being
133// partitioned, which is controlled by the kSplitCacheByNetworkIsolationKey
134// feature.
Andrew Williamsaeeec53b2024-08-20 22:32:30[diff] [blame]135BASE_FEATURE(kSplitCacheByCrossSiteMainFrameNavigationBoolean,
136 "SplitCacheByCrossSiteMainFrameNavigationBoolean",
Andrew Williams8bea9cb2025-03-13 15:08:56[diff] [blame]137 base::FEATURE_ENABLED_BY_DEFAULT);
Andrew Williamsaeeec53b2024-08-20 22:32:30[diff] [blame]138
Andrew Williamsd5fa8ad02023-03-21 21:15:43[diff] [blame]139BASE_FEATURE(kSplitCodeCacheByNetworkIsolationKey,
140 "SplitCodeCacheByNetworkIsolationKey",
141 base::FEATURE_DISABLED_BY_DEFAULT);
142
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]143BASE_FEATURE(kPartitionConnectionsByNetworkIsolationKey,
144 "PartitionConnectionsByNetworkIsolationKey",
145 base::FEATURE_DISABLED_BY_DEFAULT);
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]146
Yoav Weiss871400e2025-06-25 05:49:57[diff] [blame]147BASE_FEATURE(kPrefixCookieHttp,
148 "PrefixCookieHttp",
Yoav Weisse9489d52025-06-30 13:08:31[diff] [blame]149 base::FEATURE_ENABLED_BY_DEFAULT);
Yoav Weiss871400e2025-06-25 05:49:57[diff] [blame]150
Yoav Weiss5c096a7e2025-06-25 18:48:01[diff] [blame]151BASE_FEATURE(kPrefixCookieHostHttp,
152 "PrefixCookieHostHttp",
Yoav Weisse9489d52025-06-30 13:08:31[diff] [blame]153 base::FEATURE_ENABLED_BY_DEFAULT);
Yoav Weiss5c096a7e2025-06-25 18:48:01[diff] [blame]154
Keita Suzuki68315bc2025-01-10 00:44:38[diff] [blame]155BASE_FEATURE(kSearchEnginePreconnectInterval,
156 "SearchEnginePreconnectInterval",
157 base::FEATURE_DISABLED_BY_DEFAULT);
158
Keita Suzukic06fdca2025-04-08 06:21:46[diff] [blame]159BASE_FEATURE(kSearchEnginePreconnect2,
160 "SearchEnginePreconnect2",
161 base::FEATURE_DISABLED_BY_DEFAULT);
162
Keita Suzuki51ed960c2025-04-22 09:27:07[diff] [blame]163BASE_FEATURE_PARAM(int,
164 kIdleTimeoutInSeconds,
165 &kSearchEnginePreconnect2,
166 "IdleTimeoutInSeconds",
167 120);
168
Keita Suzukia4677332025-04-22 09:25:56[diff] [blame]169BASE_FEATURE_PARAM(base::TimeDelta,
170 kShortSessionThreshold,
171 &kSearchEnginePreconnect2,
Keita Suzuki7e43a222025-05-02 08:56:17[diff] [blame]172 "MaxShortSessionThreshold",
Keita Suzukia4677332025-04-22 09:25:56[diff] [blame]173 base::Seconds(30));
174
Keita Suzukic06fdca2025-04-08 06:21:46[diff] [blame]175extern const base::FeatureParam<int> kMaxPreconnectRetryInterval(
176 &kSearchEnginePreconnect2,
177 "MaxPreconnectRetryInterval",
178 30);
179
Keita Suzuki51ed960c2025-04-22 09:27:07[diff] [blame]180BASE_FEATURE_PARAM(int,
181 kPingIntervalInSeconds,
182 &kSearchEnginePreconnect2,
183 "PingIntervalInSeconds",
184 30);
185
Keita Suzuki6ae19def12025-06-11 04:09:31[diff] [blame]186BASE_FEATURE_PARAM(std::string,
187 kQuicConnectionOptions,
188 &kSearchEnginePreconnect2,
189 "QuicConnectionOptions",
190 "");
191
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]192BASE_FEATURE(kShortLaxAllowUnsafeThreshold,
193 "ShortLaxAllowUnsafeThreshold",
194 base::FEATURE_DISABLED_BY_DEFAULT);
Lily Chenfcddec62019-10-02 20:25:32[diff] [blame]195
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]196BASE_FEATURE(kSameSiteDefaultChecksMethodRigorously,
197 "SameSiteDefaultChecksMethodRigorously",
198 base::FEATURE_DISABLED_BY_DEFAULT);
Lily Chen80424522019-11-21 22:38:49[diff] [blame]199
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]200BASE_FEATURE(kLimitOpenUDPSockets,
201 "LimitOpenUDPSockets",
202 base::FEATURE_ENABLED_BY_DEFAULT);
Eric Roman5a841922020-08-13 01:28:25[diff] [blame]203
204extern const base::FeatureParam<int> kLimitOpenUDPSocketsMax(
205 &kLimitOpenUDPSockets,
206 "LimitOpenUDPSocketsMax",
207 6000);
208
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]209BASE_FEATURE(kTimeoutTcpConnectAttempt,
210 "TimeoutTcpConnectAttempt",
211 base::FEATURE_DISABLED_BY_DEFAULT);
Eric Romanc1c427a2020-10-01 17:29:01[diff] [blame]212
213extern const base::FeatureParam<double> kTimeoutTcpConnectAttemptRTTMultiplier(
214 &kTimeoutTcpConnectAttempt,
215 "TimeoutTcpConnectAttemptRTTMultiplier",
216 5.0);
217
218extern const base::FeatureParam<base::TimeDelta> kTimeoutTcpConnectAttemptMin(
219 &kTimeoutTcpConnectAttempt,
220 "TimeoutTcpConnectAttemptMin",
Peter Kastinge5a38ed2021-10-02 03:06:35[diff] [blame]221 base::Seconds(8));
Eric Romanc1c427a2020-10-01 17:29:01[diff] [blame]222
223extern const base::FeatureParam<base::TimeDelta> kTimeoutTcpConnectAttemptMax(
224 &kTimeoutTcpConnectAttempt,
225 "TimeoutTcpConnectAttemptMax",
Peter Kastinge5a38ed2021-10-02 03:06:35[diff] [blame]226 base::Seconds(30));
Eric Romanc1c427a2020-10-01 17:29:01[diff] [blame]227
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]228BASE_FEATURE(kCookieSameSiteConsidersRedirectChain,
229 "CookieSameSiteConsidersRedirectChain",
230 base::FEATURE_DISABLED_BY_DEFAULT);
Lily Chenf70a68d92021-06-03 01:01:41[diff] [blame]231
Anusha Muleyb25e4d9b2024-10-22 13:15:41[diff] [blame]232BASE_FEATURE(kAllowSameSiteNoneCookiesInSandbox,
233 "AllowSameSiteNoneCookiesInSandbox",
Anusha Muley5d7f45f32025-03-14 15:59:58[diff] [blame]234 base::FEATURE_ENABLED_BY_DEFAULT);
Anusha Muleyb25e4d9b2024-10-22 13:15:41[diff] [blame]235
Chris Fredrickson56234ce2023-06-26 22:13:13[diff] [blame]236BASE_FEATURE(kWaitForFirstPartySetsInit,
237 "WaitForFirstPartySetsInit",
Sam LeDouxc11f88a62023-09-22 21:17:19[diff] [blame]238 base::FEATURE_DISABLED_BY_DEFAULT);
Chris Fredrickson56234ce2023-06-26 22:13:13[diff] [blame]239
Chris Fredrickson2f66b942023-12-15 20:38:49[diff] [blame]240// Controls the maximum time duration an outermost frame navigation should be
241// deferred by RWS initialization.
242extern const base::FeatureParam<base::TimeDelta>
243 kWaitForFirstPartySetsInitNavigationThrottleTimeout{
244 &kWaitForFirstPartySetsInit,
245 "kWaitForFirstPartySetsInitNavigationThrottleTimeout",
246 base::Seconds(0)};
247
selya4ba5d3572024-12-20 20:25:05[diff] [blame]248BASE_FEATURE(kRequestStorageAccessNoCorsRequired,
249 "RequestStorageAccessNoCorsRequired",
250 base::FEATURE_DISABLED_BY_DEFAULT);
251
Chris Fredricksona7d082d2025-01-07 04:03:32[diff] [blame]252BASE_FEATURE(kStorageAccessApiFollowsSameOriginPolicy,
253 "StorageAccessApiFollowsSameOriginPolicy",
254 base::FEATURE_DISABLED_BY_DEFAULT);
255
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]256BASE_FEATURE(kStaticKeyPinningEnforcement,
257 "StaticKeyPinningEnforcement",
258 base::FEATURE_ENABLED_BY_DEFAULT);
Carlos ILf12eac92022-05-12 02:19:53[diff] [blame]259
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]260BASE_FEATURE(kCookieDomainRejectNonASCII,
261 "CookieDomainRejectNonASCII",
262 base::FEATURE_DISABLED_BY_DEFAULT);
Johann Hofmann373f5992022-06-03 09:22:18[diff] [blame]263
Chris Fredricksone139a8d72022-08-10 22:58:06[diff] [blame]264// Enables partitioning of third party storage (IndexedDB, CacheStorage, etc.)
265// by the top level site to reduce fingerprinting.
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]266BASE_FEATURE(kThirdPartyStoragePartitioning,
267 "ThirdPartyStoragePartitioning",
Kyraf5d8c2cc2023-09-28 02:01:16[diff] [blame]268 base::FEATURE_ENABLED_BY_DEFAULT);
269
Joshua Hood624ba4a2024-05-28 16:12:22[diff] [blame]270BASE_FEATURE(kTopLevelTpcdOriginTrial,
271 "TopLevelTpcdOriginTrial",
Joshua Hood4105d7d2024-06-24 16:16:07[diff] [blame]272 base::FEATURE_ENABLED_BY_DEFAULT);
Joshua Hood624ba4a2024-05-28 16:12:22[diff] [blame]273
Joshua Hoodd9083163f2024-01-18 14:49:10[diff] [blame]274BASE_FEATURE(kTpcdTrialSettings,
Joshua Hood0b269e32023-08-04 18:10:54[diff] [blame]275 "TpcdSupportSettings",
Joshua Hood3f0d6442023-12-07 16:23:47[diff] [blame]276 base::FEATURE_ENABLED_BY_DEFAULT);
Joshua Hood0b269e32023-08-04 18:10:54[diff] [blame]277
Joshua Hoodd9083163f2024-01-18 14:49:10[diff] [blame]278BASE_FEATURE(kTopLevelTpcdTrialSettings,
Joshua Hoode0e1ac6a2024-01-12 14:43:57[diff] [blame]279 "TopLevelTpcdSupportSettings",
Joshua Hoodaf55f672024-07-23 19:56:28[diff] [blame]280 base::FEATURE_ENABLED_BY_DEFAULT);
Joshua Hoode0e1ac6a2024-01-12 14:43:57[diff] [blame]281
Jonathan Njeunje70e46a22023-08-25 14:58:45[diff] [blame]282BASE_FEATURE(kTpcdMetadataGrants,
283 "TpcdMetadataGrants",
Jonathan Njeunje358f6a12023-12-06 23:46:51[diff] [blame]284 base::FEATURE_ENABLED_BY_DEFAULT);
Jonathan Njeunje70e46a22023-08-25 14:58:45[diff] [blame]285
Jonathan Njeunje5f28cff2024-05-14 08:58:16[diff] [blame]286BASE_FEATURE(kTpcdMetadataStageControl,
Jonathan Njeunjefac83d32024-03-28 15:02:56[diff] [blame]287 "TpcdMetadataStageControl",
Jonathan Njeunjeaedb99ec2024-05-30 17:33:27[diff] [blame]288 base::FEATURE_ENABLED_BY_DEFAULT);
Jonathan Njeunjefac83d32024-03-28 15:02:56[diff] [blame]289
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]290BASE_FEATURE(kAlpsParsing, "AlpsParsing", base::FEATURE_ENABLED_BY_DEFAULT);
Ari Chivukula369a96a02022-08-22 17:52:22[diff] [blame]291
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]292BASE_FEATURE(kAlpsClientHintParsing,
293 "AlpsClientHintParsing",
294 base::FEATURE_ENABLED_BY_DEFAULT);
Ari Chivukula33a8977162022-08-25 11:53:59[diff] [blame]295
Daniel Cheng2fff35702022-09-21 16:44:52[diff] [blame]296BASE_FEATURE(kShouldKillSessionOnAcceptChMalformed,
297 "ShouldKillSessionOnAcceptChMalformed",
298 base::FEATURE_DISABLED_BY_DEFAULT);
Ari Chivukula33a8977162022-08-25 11:53:59[diff] [blame]299
Momoka Yamamotof7962482022-10-07 13:56:10[diff] [blame]300BASE_FEATURE(kEnableWebsocketsOverHttp3,
301 "EnableWebsocketsOverHttp3",
302 base::FEATURE_DISABLED_BY_DEFAULT);
303
David Benjamin88493202022-11-12 14:22:35[diff] [blame]304#if BUILDFLAG(IS_WIN)
Will Harrise6fea7f2023-10-19 02:47:32[diff] [blame]305// Disabled because of https://crbug.com/1489696.
Will Harris4bf42102023-09-29 00:29:49[diff] [blame]306BASE_FEATURE(kEnableGetNetworkConnectivityHintAPI,
307 "EnableGetNetworkConnectivityHintAPI",
Will Harrise6fea7f2023-10-19 02:47:32[diff] [blame]308 base::FEATURE_DISABLED_BY_DEFAULT);
Erik Andersonde9ae7d2024-04-23 04:20:16[diff] [blame]309
Ari Chivukula70b4390c2025-05-23 13:12:27[diff] [blame]310BASE_FEATURE(kTcpPortRandomizationWin,
311 "TcpPortRandomizationWin",
Erik Andersonde9ae7d2024-04-23 04:20:16[diff] [blame]312 base::FEATURE_DISABLED_BY_DEFAULT);
François Doray70382d02024-09-19 16:28:45[diff] [blame]313
Ari Chivukula70b4390c2025-05-23 13:12:27[diff] [blame]314BASE_FEATURE_PARAM(int,
315 kTcpPortRandomizationWinVersionMinimum,
316 &kTcpPortRandomizationWin,
317 "TcpPortRandomizationWinVersionMinimum",
Ari Chivukula9173d602025-06-20 14:58:23[diff] [blame]318 static_cast<int>(base::win::Version::WIN11_22H2));
Ari Chivukula70b4390c2025-05-23 13:12:27[diff] [blame]319
Ari Chivukula16e17792025-06-06 03:43:21[diff] [blame]320BASE_FEATURE(kTcpPortReuseMetricsWin,
321 "TcpPortReuseMetricsWin",
322 base::FEATURE_ENABLED_BY_DEFAULT);
323
François Doray70382d02024-09-19 16:28:45[diff] [blame]324BASE_FEATURE(kTcpSocketIoCompletionPortWin,
325 "TcpSocketIoCompletionPortWin",
326 base::FEATURE_DISABLED_BY_DEFAULT);
David Benjamin88493202022-11-12 14:22:35[diff] [blame]327#endif
328
Olivier Li Shing Tat-Dupuis1e069dd2024-05-10 18:15:42[diff] [blame]329BASE_FEATURE(kAvoidEntryCreationForNoStore,
330 "AvoidEntryCreationForNoStore",
331 base::FEATURE_DISABLED_BY_DEFAULT);
332const base::FeatureParam<int> kAvoidEntryCreationForNoStoreCacheSize{
333 &kAvoidEntryCreationForNoStore, "AvoidEntryCreationForNoStoreCacheSize",
334 1000};
335
slutskii4171f8b72023-03-01 23:46:06[diff] [blame]336// A flag for new Kerberos feature, that suggests new UI
337// when Kerberos authentication in browser fails on ChromeOS.
338// b/260522530
339#if BUILDFLAG(IS_CHROMEOS)
340BASE_FEATURE(kKerberosInBrowserRedirect,
341 "KerberosInBrowserRedirect",
slutskii28935202023-05-24 17:40:50[diff] [blame]342 base::FEATURE_ENABLED_BY_DEFAULT);
slutskii4171f8b72023-03-01 23:46:06[diff] [blame]343#endif
344
Liza Burakova86312a82023-03-23 21:24:49[diff] [blame]345// A flag to use asynchronous session creation for new QUIC sessions.
346BASE_FEATURE(kAsyncQuicSession,
347 "AsyncQuicSession",
Will Harris10dcebaf2023-08-01 17:42:15[diff] [blame]348#if BUILDFLAG(IS_WIN)
349 base::FEATURE_ENABLED_BY_DEFAULT);
350#else
Liza Burakova86312a82023-03-23 21:24:49[diff] [blame]351 base::FEATURE_DISABLED_BY_DEFAULT);
Will Harris10dcebaf2023-08-01 17:42:15[diff] [blame]352#endif
Liza Burakova86312a82023-03-23 21:24:49[diff] [blame]353
Liza Burakova7ac2b962023-07-11 16:06:27[diff] [blame]354// A flag to make multiport context creation asynchronous.
355BASE_FEATURE(kAsyncMultiPortPath,
356 "AsyncMultiPortPath",
357#if !BUILDFLAG(CRONET_BUILD) && (BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID))
358 base::FEATURE_ENABLED_BY_DEFAULT);
359#else
360 base::FEATURE_DISABLED_BY_DEFAULT);
361#endif
362
Ryan Kalla08ff1dc2025-04-03 12:49:19[diff] [blame]363// Probabilistic reveal tokens configuration settings
364BASE_FEATURE(kEnableProbabilisticRevealTokens,
365 "EnableProbabilisticRevealTokens",
366 base::FEATURE_DISABLED_BY_DEFAULT);
367
368const base::FeatureParam<std::string> kProbabilisticRevealTokenServer{
369 &kEnableProbabilisticRevealTokens,
370 /*name=*/"ProbabilisticRevealTokenServer",
371 /*default_value=*/"https://aaftokenissuer.pa.googleapis.com"};
372
373const base::FeatureParam<std::string> kProbabilisticRevealTokenServerPath{
374 &kEnableProbabilisticRevealTokens,
375 /*name=*/"ProbabilisticRevealTokenServerPath",
376 /*default_value=*/"/v1/issueprts"};
377
Ryan Kallaeda9eec2025-04-25 21:27:15[diff] [blame]378const base::FeatureParam<bool> kBypassProbabilisticRevealTokenRegistry{
379 &kEnableProbabilisticRevealTokens,
380 /*name=*/"BypassProbabilisticRevealTokenRegistry",
381 /*default_value=*/false};
382
383const base::FeatureParam<bool> kUseCustomProbabilisticRevealTokenRegistry{
384 &kEnableProbabilisticRevealTokens,
385 /*name=*/"UseCustomProbabilisticRevealTokenRegistry",
386 /*default_value=*/false};
387
388const base::FeatureParam<std::string> kCustomProbabilisticRevealTokenRegistry{
389 &kEnableProbabilisticRevealTokens,
390 /*name=*/"CustomProbabilisticRevealTokenRegistry",
391 /*default_value=*/""};
392
393const base::FeatureParam<bool> kProbabilisticRevealTokensOnlyInIncognito{
394 &kEnableProbabilisticRevealTokens,
395 /*name=*/"ProbabilisticRevealTokensOnlyInIncognito",
396 /*default_value=*/false};
397
398const base::FeatureParam<bool> kProbabilisticRevealTokenFetchOnly{
399 &kEnableProbabilisticRevealTokens,
400 /*name=*/"ProbabilisticRevealTokenFetchOnly",
401 /*default_value=*/false};
402
Ryan Kalla08ff1dc2025-04-03 12:49:19[diff] [blame]403const base::FeatureParam<bool>
Ryan Kallaeda9eec2025-04-25 21:27:15[diff] [blame]404 kEnableProbabilisticRevealTokensForNonProxiedRequests{
Ryan Kalla08ff1dc2025-04-03 12:49:19[diff] [blame]405 &kEnableProbabilisticRevealTokens,
Ryan Kallaeda9eec2025-04-25 21:27:15[diff] [blame]406 /*name=*/"EnableProbabilisticRevealTokensForNonProxiedRequests",
Ryan Kalla08ff1dc2025-04-03 12:49:19[diff] [blame]407 /*default_value=*/false};
408
Aykut Bulut331b0e22025-04-25 00:58:40[diff] [blame]409const base::FeatureParam<bool>
410 kProbabilisticRevealTokensAddHeaderToProxiedRequests{
411 &kEnableProbabilisticRevealTokens,
412 /*name=*/"ProbabilisticRevealTokensAddHeaderToProxiedRequests",
413 /*default_value=*/false};
414
Brianna Goldsteinf457c2f2023-03-15 00:36:50[diff] [blame]415// IP protection experiment configuration settings
416BASE_FEATURE(kEnableIpProtectionProxy,
417 "EnableIpPrivacyProxy",
418 base::FEATURE_DISABLED_BY_DEFAULT);
419
Andrew Williams3b434e92023-08-23 01:49:24[diff] [blame]420const base::FeatureParam<std::string> kIpPrivacyTokenServer{
421 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyTokenServer",
Ciara McMullin60a5a2ac2024-10-28 16:28:21[diff] [blame]422 /*default_value=*/"https://prod.ipprotectionauth.goog"};
Andrew Williams3b434e92023-08-23 01:49:24[diff] [blame]423
424const base::FeatureParam<std::string> kIpPrivacyTokenServerGetInitialDataPath{
425 &kEnableIpProtectionProxy,
426 /*name=*/"IpPrivacyTokenServerGetInitialDataPath",
Andrew Williams82f6fdf72023-09-08 22:59:26[diff] [blame]427 /*default_value=*/"/v1/ipblinding/getInitialData"};
Andrew Williams3b434e92023-08-23 01:49:24[diff] [blame]428
429const base::FeatureParam<std::string> kIpPrivacyTokenServerGetTokensPath{
430 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyTokenServerGetTokensPath",
Andrew Williams82f6fdf72023-09-08 22:59:26[diff] [blame]431 /*default_value=*/"/v1/ipblinding/auth"};
Andrew Williams3b434e92023-08-23 01:49:24[diff] [blame]432
Dustin J. Mitchellc9fa2482023-09-05 22:54:55[diff] [blame]433const base::FeatureParam<std::string> kIpPrivacyTokenServerGetProxyConfigPath{
434 &kEnableIpProtectionProxy,
435 /*name=*/"IpPrivacyTokenServerGetProxyConfigPath",
436 /*default_value=*/"/v1/ipblinding/getProxyConfig"};
437
Dustin J. Mitchell323bb0b2023-08-16 13:26:08[diff] [blame]438const base::FeatureParam<int> kIpPrivacyAuthTokenCacheBatchSize{
439 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyAuthTokenCacheBatchSize",
440 /*default_value=*/64};
441
442const base::FeatureParam<int> kIpPrivacyAuthTokenCacheLowWaterMark{
443 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyAuthTokenCacheLowWaterMark",
444 /*default_value=*/16};
445
Dustin J. Mitchellc69f62782023-09-01 12:56:03[diff] [blame]446const base::FeatureParam<base::TimeDelta> kIpPrivacyProxyListFetchInterval{
447 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyListFetchInterval",
448 /*default_value=*/base::Hours(1)};
449
450const base::FeatureParam<base::TimeDelta> kIpPrivacyProxyListMinFetchInterval{
451 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyMinListFetchInterval",
452 /*default_value=*/base::Minutes(1)};
453
Ciara McMullin6f72d102024-09-06 17:26:14[diff] [blame]454const base::FeatureParam<base::TimeDelta> kIpPrivacyProxyListFetchIntervalFuzz{
455 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyListFetchIntervalFuzz",
456 /*default_value=*/base::Minutes(30)};
457
Dustin J. Mitchellc69f62782023-09-01 12:56:03[diff] [blame]458const base::FeatureParam<bool> kIpPrivacyDirectOnly{
459 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyDirectOnly",
460 /*default_value=*/false};
461
Raja Abdulhaqe7393442023-12-21 22:11:56[diff] [blame]462const base::FeatureParam<bool> kIpPrivacyIncludeOAuthTokenInGetProxyConfig{
463 &kEnableIpProtectionProxy,
464 /*name=*/"IpPrivacyIncludeOAuthTokenInGetProxyConfig",
465 /*default_value=*/false};
466
Scott Hendrickson1768ab1a2023-12-06 13:09:42[diff] [blame]467const base::FeatureParam<std::string> kIpPrivacyProxyAHostnameOverride{
468 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyAHostnameOverride",
469 /*default_value=*/""};
470
471const base::FeatureParam<std::string> kIpPrivacyProxyBHostnameOverride{
472 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyBHostnameOverride",
473 /*default_value=*/""};
474
Andrew Williams21904d4e2024-01-03 21:35:25[diff] [blame]475const base::FeatureParam<bool> kIpPrivacyAddHeaderToProxiedRequests{
476 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyAddHeaderToProxiedRequests",
477 /*default_value=*/false};
478
Dustin J. Mitchell274291b2024-02-15 15:38:54[diff] [blame]479const base::FeatureParam<base::TimeDelta> kIpPrivacyExpirationFuzz{
480 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyExpirationFuzz",
481 /*default_value=*/base::Minutes(15)};
482
Ciara McMullin975baea2024-11-19 22:09:59[diff] [blame]483const base::FeatureParam<base::TimeDelta>
484 kIpPrivacyTryGetAuthTokensNotEligibleBackoff{
485 &kEnableIpProtectionProxy,
486 /*name=*/"IpPrivacyTryGetAuthTokensNotEligibleBackoff",
Ciara McMullin2a1b7942024-12-10 15:14:05[diff] [blame]487 /*default_value=*/base::Hours(1)};
Ciara McMullin975baea2024-11-19 22:09:59[diff] [blame]488
489const base::FeatureParam<base::TimeDelta>
490 kIpPrivacyTryGetAuthTokensTransientBackoff{
491 &kEnableIpProtectionProxy,
492 /*name=*/"IpPrivacyTryGetAuthTokensTransientBackoff",
493 /*default_value=*/base::Seconds(5)};
494
495const base::FeatureParam<base::TimeDelta> kIpPrivacyTryGetAuthTokensBugBackoff{
496 &kEnableIpProtectionProxy, /*name=*/"IpPrivacyTryGetAuthTokensBugBackoff",
497 /*default_value=*/base::Minutes(10)};
498
Andrew Williams1828d1f2024-03-11 16:57:42[diff] [blame]499const base::FeatureParam<bool> kIpPrivacyRestrictTopLevelSiteSchemes{
500 &kEnableIpProtectionProxy,
501 /*name=*/"IpPrivacyRestrictTopLevelSiteSchemes",
502 /*default_value=*/true};
503
Dustin J. Mitchella3030132024-04-09 16:12:50[diff] [blame]504const base::FeatureParam<bool> kIpPrivacyUseQuicProxies{
505 &kEnableIpProtectionProxy,
506 /*name=*/"IpPrivacyUseQuicProxies",
507 /*default_value=*/false};
508
509const base::FeatureParam<bool> kIpPrivacyUseQuicProxiesOnly{
510 &kEnableIpProtectionProxy,
511 /*name=*/"IpPrivacyUseQuicProxiesOnly",
512 /*default_value=*/false};
513
Dustin J. Mitchell583df5d2024-04-18 20:50:31[diff] [blame]514const base::FeatureParam<bool> kIpPrivacyFallbackToDirect{
515 &kEnableIpProtectionProxy,
516 /*name=*/"IpPrivacyFallbackToDirect",
517 /*default_value=*/true};
518
Dustin J. Mitchell7cfca7082024-06-04 21:06:09[diff] [blame]519const base::FeatureParam<int> kIpPrivacyDebugExperimentArm{
520 &kEnableIpProtectionProxy,
521 /*name=*/"IpPrivacyDebugExperimentArm",
522 /*default_value=*/0};
523
Abhi Patel9b7ac032024-10-25 15:25:45[diff] [blame]524const base::FeatureParam<bool> kIpPrivacyAlwaysCreateCore{
525 &kEnableIpProtectionProxy,
526 /*name=*/"IpPrivacyAlwaysCreateCore",
527 /*default_value=*/false};
528
Abhi Patel7ee8b4d2024-11-01 21:06:08[diff] [blame]529const base::FeatureParam<bool> kIpPrivacyOnlyInIncognito{
530 &kEnableIpProtectionProxy,
531 /*name=*/"IpPrivacyOnlyInIncognito",
532 /*default_value=*/false};
533
Abhi Pateld00da532025-02-28 18:59:24[diff] [blame]534const base::FeatureParam<bool> kIpPrivacyEnableUserBypass{
535 &kEnableIpProtectionProxy,
536 /*name=*/"IpPrivacyEnableUserBypass",
537 /*default_value=*/false};
538
Andrew Williamsb24c0a7f2025-05-08 13:12:34[diff] [blame]539const base::FeatureParam<bool> kIpPrivacyDisableForEnterpriseByDefault{
540 &kEnableIpProtectionProxy,
541 /*name=*/"IpPrivacyDisableForEnterpriseByDefault",
542 /*default_value=*/false};
543
Antonio Alphonsea50a8ef2025-06-18 15:39:17[diff] [blame]544const base::FeatureParam<bool> kIpPrivacyEnableIppInDevTools{
545 &kEnableIpProtectionProxy,
546 /*name=*/"IpPrivacyEnableIppInDevTools",
547 /*default_value=*/false};
548
Hannah Su2dc0c2e52025-07-15 10:21:18[diff] [blame]549const base::FeatureParam<bool> kIpPrivacyEnableIppPanelInDevTools{
550 &kEnableIpProtectionProxy,
551 /*name=*/"kIpPrivacyEnableIppPanelInDevTools",
552 /*default_value=*/false};
553
Mayur Patil34c593c2025-02-25 04:43:28[diff] [blame]554BASE_FEATURE(kExcludeLargeBodyReports,
555 "ExcludeLargeReportBodies",
556 base::FEATURE_ENABLED_BY_DEFAULT);
557
558BASE_FEATURE_PARAM(size_t,
559 kMaxReportBodySizeKB,
560 &kExcludeLargeBodyReports,
561 "max_report_body_size_kb",
562 1024);
563
Anusha Muleya893e9252025-04-08 21:16:07[diff] [blame]564BASE_FEATURE(kRelatedWebsitePartitionAPI,
565 "RelatedWebsitePartitionAPI",
566 base::FEATURE_DISABLED_BY_DEFAULT);
567
Stefano Duo73063a32023-04-04 14:06:51[diff] [blame]568// Network-change migration requires NetworkHandle support, which are currently
569// only supported on Android (see
570// NetworkChangeNotifier::AreNetworkHandlesSupported).
571#if BUILDFLAG(IS_ANDROID)
572inline constexpr auto kMigrateSessionsOnNetworkChangeV2Default =
Mohannad Farrag539128b2024-01-12 15:46:14[diff] [blame]573 base::FEATURE_ENABLED_BY_DEFAULT;
Stefano Duo73063a32023-04-04 14:06:51[diff] [blame]574#else // !BUILDFLAG(IS_ANDROID)
575inline constexpr auto kMigrateSessionsOnNetworkChangeV2Default =
576 base::FEATURE_DISABLED_BY_DEFAULT;
577#endif // BUILDFLAG(IS_ANDROID)
578BASE_FEATURE(kMigrateSessionsOnNetworkChangeV2,
579 "MigrateSessionsOnNetworkChangeV2",
580 kMigrateSessionsOnNetworkChangeV2Default);
581
Mohannad Farraga6d8f8e2023-06-26 19:45:14[diff] [blame]582BASE_FEATURE(kDisableBlackholeOnNoNewNetwork,
583 "DisableBlackHoleOnNoNewNetwork",
584 base::FEATURE_DISABLED_BY_DEFAULT);
585
Matthew Dentonfa68c9c2023-04-17 07:39:31[diff] [blame]586#if BUILDFLAG(IS_LINUX)
587BASE_FEATURE(kAddressTrackerLinuxIsProxied,
588 "AddressTrackerLinuxIsProxied",
589 base::FEATURE_ENABLED_BY_DEFAULT);
590#endif // BUILDFLAG(IS_LINUX)
591
sbingler62efd892023-05-03 19:06:20[diff] [blame]592// Enables binding of cookies to the port that originally set them by default.
593BASE_FEATURE(kEnablePortBoundCookies,
594 "EnablePortBoundCookies",
595 base::FEATURE_DISABLED_BY_DEFAULT);
596
597// Enables binding of cookies to the scheme that originally set them.
598NET_EXPORT BASE_DECLARE_FEATURE(kEnableSchemeBoundCookies);
599BASE_FEATURE(kEnableSchemeBoundCookies,
600 "EnableSchemeBoundCookies",
601 base::FEATURE_DISABLED_BY_DEFAULT);
602
amarjotgillf61674a2025-01-09 21:17:48[diff] [blame]603// Disallows cookies to have non ascii values in their name or value.
604NET_EXPORT BASE_DECLARE_FEATURE(kDisallowNonAsciiCookies);
605BASE_FEATURE(kDisallowNonAsciiCookies,
amarjotgill129840962025-02-06 14:32:26[diff] [blame]606 "DisallowNonAsciiCookies",
amarjotgillf61674a2025-01-09 21:17:48[diff] [blame]607 base::FEATURE_DISABLED_BY_DEFAULT);
608
Carlos IL00ab134a2023-12-18 22:22:41[diff] [blame]609BASE_FEATURE(kTimeLimitedInsecureCookies,
610 "TimeLimitedInsecureCookies",
611 base::FEATURE_DISABLED_BY_DEFAULT);
612
Dylan Cutlerccf6d5422023-05-22 12:08:23[diff] [blame]613// Enable third-party cookie blocking from the command line.
614BASE_FEATURE(kForceThirdPartyCookieBlocking,
615 "ForceThirdPartyCookieBlockingEnabled",
616 base::FEATURE_DISABLED_BY_DEFAULT);
617
Kenichi Ishibashi5ca5a1772023-06-13 06:32:11[diff] [blame]618BASE_FEATURE(kEnableEarlyHintsOnHttp11,
619 "EnableEarlyHintsOnHttp11",
620 base::FEATURE_DISABLED_BY_DEFAULT);
621
Victor Vasiliev4f934962023-07-10 18:12:52[diff] [blame]622BASE_FEATURE(kEnableWebTransportDraft07,
623 "EnableWebTransportDraft07",
624 base::FEATURE_DISABLED_BY_DEFAULT);
625
Javier Fernández García-Boente628b71552025-06-23 20:26:54[diff] [blame]626BASE_FEATURE(kWebTransportFineGrainedThrottling,
627 "WebTransportFineGrainedThrottling",
628 base::FEATURE_DISABLED_BY_DEFAULT);
629
sbinglere83ad48b2023-08-28 18:57:04[diff] [blame]630// When enabled, partitioned storage will be allowed even if third-party cookies
631// are disabled by default. Partitioned storage will not be allowed if
632// third-party cookies are disabled due to a specific rule.
sbinglere83ad48b2023-08-28 18:57:04[diff] [blame]633BASE_FEATURE(kThirdPartyPartitionedStorageAllowedByDefault,
634 "ThirdPartyPartitionedStorageAllowedByDefault",
Steven Bingler6bf7d852023-09-29 22:15:40[diff] [blame]635 base::FEATURE_ENABLED_BY_DEFAULT);
sbinglere83ad48b2023-08-28 18:57:04[diff] [blame]636
Adam Rice9b9e7c522023-09-28 06:27:43[diff] [blame]637BASE_FEATURE(kSpdyHeadersToHttpResponseUseBuilder,
638 "SpdyHeadersToHttpResponseUseBuilder",
639 base::FEATURE_DISABLED_BY_DEFAULT);
640
Victor Tan2d266752023-12-07 20:19:56[diff] [blame]641BASE_FEATURE(kUseNewAlpsCodepointHttp2,
642 "UseNewAlpsCodepointHttp2",
Victor Tan90243a72025-02-11 00:06:17[diff] [blame]643 base::FEATURE_ENABLED_BY_DEFAULT);
Victor Tan914785302023-11-08 15:59:50[diff] [blame]644
Victor Tan7ccd5fe2023-12-08 22:23:13[diff] [blame]645BASE_FEATURE(kUseNewAlpsCodepointQUIC,
646 "UseNewAlpsCodepointQUIC",
Victor Tan90243a72025-02-11 00:06:17[diff] [blame]647 base::FEATURE_ENABLED_BY_DEFAULT);
Victor Tan7ccd5fe2023-12-08 22:23:13[diff] [blame]648
Nidhi Jaju7b37e012024-02-19 10:00:31[diff] [blame]649BASE_FEATURE(kTruncateBodyToContentLength,
650 "TruncateBodyToContentLength",
651 base::FEATURE_ENABLED_BY_DEFAULT);
652
Tsuyoshi Horo93f8e3b6e2024-03-11 04:04:22[diff] [blame]653#if BUILDFLAG(IS_MAC)
654BASE_FEATURE(kReduceIPAddressChangeNotification,
655 "ReduceIPAddressChangeNotification",
Tsuyoshi Horo97338d7d2024-03-18 13:05:22[diff] [blame]656 base::FEATURE_ENABLED_BY_DEFAULT);
Tsuyoshi Horo93f8e3b6e2024-03-11 04:04:22[diff] [blame]657#endif // BUILDFLAG(IS_MAC)
658
Kristian Monsend56563ce2024-03-18 23:32:00[diff] [blame]659BASE_FEATURE(kDeviceBoundSessions,
660 "DeviceBoundSessions",
661 base::FEATURE_DISABLED_BY_DEFAULT);
Anunoy Ghoshc52cd7e02024-10-31 12:03:43[diff] [blame]662BASE_FEATURE(kPersistDeviceBoundSessions,
663 "PersistDeviceBoundSessions",
664 base::FEATURE_DISABLED_BY_DEFAULT);
Daniel Rubery2aaa0e32025-03-04 04:45:13[diff] [blame]665BASE_FEATURE_PARAM(bool,
666 kDeviceBoundSessionsForceEnableForTesting,
667 &kDeviceBoundSessions,
668 "ForceEnableForTesting",
669 false);
thefroge7b8f2552025-03-03 18:27:38[diff] [blame]670BASE_FEATURE(kDeviceBoundSessionsRefreshQuota,
671 "DeviceBoundSessionsRefreshQuota",
672 base::FEATURE_ENABLED_BY_DEFAULT);
Kristian Monsend56563ce2024-03-18 23:32:00[diff] [blame]673
Dustin J. Mitchelle520f992024-05-30 17:23:26[diff] [blame]674BASE_FEATURE(kPartitionProxyChains,
675 "PartitionProxyChains",
Ciara McMullin46d9e912025-05-05 19:02:06[diff] [blame]676 base::FEATURE_DISABLED_BY_DEFAULT);
Dustin J. Mitchelle520f992024-05-30 17:23:26[diff] [blame]677
Kenichi Ishibashi76553e32024-05-31 01:03:42[diff] [blame]678BASE_FEATURE(kSpdySessionForProxyAdditionalChecks,
679 "SpdySessionForProxyAdditionalChecks",
680 base::FEATURE_ENABLED_BY_DEFAULT);
681
Tsuyoshi Horoaae3d152024-07-01 23:28:50[diff] [blame]682BASE_FEATURE(kCompressionDictionaryTransportOverHttp1,
683 "CompressionDictionaryTransportOverHttp1",
684 base::FEATURE_ENABLED_BY_DEFAULT);
685
686BASE_FEATURE(kCompressionDictionaryTransportOverHttp2,
687 "CompressionDictionaryTransportOverHttp2",
688 base::FEATURE_ENABLED_BY_DEFAULT);
689
690BASE_FEATURE(kCompressionDictionaryTransportRequireKnownRootCert,
691 "CompressionDictionaryTransportRequireKnownRootCert",
Tsuyoshi Horofaacb0a2024-08-30 23:29:26[diff] [blame]692 base::FEATURE_ENABLED_BY_DEFAULT);
Tsuyoshi Horoaae3d152024-07-01 23:28:50[diff] [blame]693
Erin Stewartce45232e2024-06-25 01:48:58[diff] [blame]694BASE_FEATURE(kReportingApiEnableEnterpriseCookieIssues,
695 "ReportingApiEnableEnterpriseCookieIssues",
696 base::FEATURE_DISABLED_BY_DEFAULT);
697
Nidhi Jaju52b25dc62024-12-05 01:31:36[diff] [blame]698BASE_FEATURE(kSimdutfBase64Support,
699 "SimdutfBase64Support",
700 base::FEATURE_DISABLED_BY_DEFAULT);
701
Nidhi Jaju84812c2a2024-12-06 02:14:28[diff] [blame]702BASE_FEATURE(kFurtherOptimizeParsingDataUrls,
703 "FurtherOptimizeParsingDataUrls",
704 base::FEATURE_ENABLED_BY_DEFAULT);
705
Jeremy Roman48f63142024-09-10 05:03:18[diff] [blame]706BASE_FEATURE(kNoVarySearchIgnoreUnrecognizedKeys,
707 "NoVarySearchIgnoreUnrecognizedKeys",
708 base::FEATURE_ENABLED_BY_DEFAULT);
709
Will Harrisa80bfcfc2024-09-20 21:57:52[diff] [blame]710BASE_FEATURE(kEncryptedAndPlaintextValuesAreInvalid,
711 "EncryptedAndPlaintextValuesAreInvalid",
Will Harris2fce84c2024-10-03 16:18:43[diff] [blame]712 base::FEATURE_ENABLED_BY_DEFAULT);
Will Harrisa80bfcfc2024-09-20 21:57:52[diff] [blame]713
Mustafa Emre Acerf961e4982024-10-07 22:35:49[diff] [blame]714BASE_FEATURE(kEnableStaticCTAPIEnforcement,
715 "EnableStaticCTAPIEnforcement",
Mustafa Emre Acer25cb1f92024-10-23 21:38:38[diff] [blame]716 base::FEATURE_ENABLED_BY_DEFAULT);
Mustafa Emre Acerf961e4982024-10-07 22:35:49[diff] [blame]717
Hayato Itoc91a3422024-10-10 02:19:07[diff] [blame]718BASE_FEATURE(kDiskCacheBackendExperiment,
719 "DiskCacheBackendExperiment",
720 base::FEATURE_DISABLED_BY_DEFAULT);
721constexpr base::FeatureParam<DiskCacheBackend>::Option
722 kDiskCacheBackendOptions[] = {
723 {DiskCacheBackend::kSimple, "simple"},
724 {DiskCacheBackend::kBlockfile, "blockfile"},
725};
726const base::FeatureParam<DiskCacheBackend> kDiskCacheBackendParam{
727 &kDiskCacheBackendExperiment, "backend", DiskCacheBackend::kBlockfile,
728 &kDiskCacheBackendOptions};
729
Eric Lawrencea5e738f22024-10-30 16:55:58[diff] [blame]730BASE_FEATURE(kIgnoreHSTSForLocalhost,
731 "IgnoreHSTSForLocalhost",
732 base::FEATURE_ENABLED_BY_DEFAULT);
733
Tsuyoshi Horo4be7529b2024-11-26 08:54:52[diff] [blame]734BASE_FEATURE(kSimpleCachePrioritizedCaching,
735 "SimpleCachePrioritizedCaching",
Tsuyoshi Horo8aeb87462025-02-17 11:37:23[diff] [blame]736 base::FEATURE_ENABLED_BY_DEFAULT);
Tsuyoshi Horo4be7529b2024-11-26 08:54:52[diff] [blame]737
738const base::FeatureParam<int>
739 kSimpleCachePrioritizedCachingPrioritizationFactor{
740 &kSimpleCachePrioritizedCaching,
741 /*name=*/"SimpleCachePrioritizedCachingPrioritizationFactor",
742 /*default_value=*/10};
743
744const base::FeatureParam<base::TimeDelta>
745 kSimpleCachePrioritizedCachingPrioritizationPeriod{
746 &kSimpleCachePrioritizedCaching,
747 /*name=*/"SimpleCachePrioritizedCachingPrioritizationPeriod",
748 /*default_value=*/base::Days(1)};
749
Matt Mueller33076cc2024-12-04 01:55:46[diff] [blame]750#if BUILDFLAG(USE_NSS_CERTS)
Matt Mueller7a1e32a2025-04-02 18:54:50[diff] [blame]751// TODO(crbug.com/390333881): Remove this flag after a few milestones.
Matt Mueller33076cc2024-12-04 01:55:46[diff] [blame]752BASE_FEATURE(kNewClientCertPathBuilding,
753 "NewClientCertPathBuilding",
754 base::FEATURE_ENABLED_BY_DEFAULT);
755#endif // BUILDFLAG(USE_NSS_CERTS)
756
sbinglere0bc0952024-12-13 18:09:12[diff] [blame]757BASE_FEATURE(kHstsTopLevelNavigationsOnly,
758 "HstsTopLevelNavigationsOnly",
759 base::FEATURE_DISABLED_BY_DEFAULT);
760
Adam Rice5d93dd5e2025-01-17 10:28:50[diff] [blame]761BASE_FEATURE(kHttpCacheNoVarySearch,
762 "HttpCacheNoVarySearch",
763 base::FEATURE_DISABLED_BY_DEFAULT);
764
765BASE_FEATURE_PARAM(size_t,
766 kHttpCacheNoVarySearchCacheMaxEntries,
767 &kHttpCacheNoVarySearch,
768 "max_entries",
769 1000);
770
Viktoria Zlatinovaf237fc02025-01-29 17:16:25[diff] [blame]771BASE_FEATURE(kReportingApiCorsOriginHeader,
772 "ReportingApiCorsOriginHeader",
773 base::FEATURE_ENABLED_BY_DEFAULT);
774
Chidera Olibie46325582025-01-31 10:35:28[diff] [blame]775#if BUILDFLAG(IS_ANDROID)
776BASE_FEATURE(kUseCertTransparencyAwareApiForOsCertVerify,
777 "UseCertTransparencyAwareApiForOsCertVerify",
778 base::FEATURE_ENABLED_BY_DEFAULT);
779#endif // BUILDFLAG(IS_ANDROID)
780
Carlos IL9f2a0252025-02-25 22:23:48[diff] [blame]781BASE_FEATURE(kSelfSignedLocalNetworkInterstitial,
782 "SelfSignedLocalNetworkInterstitial",
783 base::FEATURE_DISABLED_BY_DEFAULT);
784
Matt Mueller9e5916c2025-03-12 01:56:59[diff] [blame]785#if BUILDFLAG(CHROME_ROOT_STORE_SUPPORTED)
786BASE_FEATURE(kVerifyQWACs, "VerifyQWACs", base::FEATURE_DISABLED_BY_DEFAULT);
787#endif // BUILDFLAG(CHROME_ROOT_STORE_SUPPORTED)
788
David Benjamind57189442025-04-16 20:44:33[diff] [blame]789#if BUILDFLAG(IS_MAC)
790BASE_FEATURE(kIncludeDeprecatedClientCertLookup,
791 "IncludeDeprecatedClientCertLookup",
792 base::FEATURE_DISABLED_BY_DEFAULT);
793#endif
794
Tom Van Goethem8f760752025-04-24 01:28:53[diff] [blame]795BASE_FEATURE(kRestrictAbusePorts,
796 "RestrictAbusePorts",
797 base::FEATURE_DISABLED_BY_DEFAULT);
Tom Van Goethem8f760752025-04-24 01:28:53[diff] [blame]798
Tom Van Goethem59535072025-05-09 11:07:29[diff] [blame]799BASE_FEATURE(kRestrictAbusePortsOnLocalhost,
800 "RestrictAbusePortsOnLocalhost",
Tom Van Goethemd9774012025-05-30 23:10:39[diff] [blame]801 base::FEATURE_ENABLED_BY_DEFAULT);
Tom Van Goethem59535072025-05-09 11:07:29[diff] [blame]802
Emily Stark047975242025-06-04 18:14:34[diff] [blame]803BASE_FEATURE(kTLSTrustAnchorIDs,
804 "TLSTrustAnchorIDs",
805 base::FEATURE_DISABLED_BY_DEFAULT);
806
Ari Chivukulab52939e2025-06-18 14:12:53[diff] [blame]807BASE_FEATURE(kTcpConnectionPoolSizeTrial,
808 "TcpConnectionPoolSizeTrial",
809 base::FEATURE_DISABLED_BY_DEFAULT);
810
811BASE_FEATURE_PARAM(int,
812 kTcpConnectionPoolSizeTrialNormal,
813 &kTcpConnectionPoolSizeTrial,
814 "TcpConnectionPoolSizeTrialNormal",
815 256);
816
817BASE_FEATURE_PARAM(int,
818 kTcpConnectionPoolSizeTrialWebSocket,
819 &kTcpConnectionPoolSizeTrial,
820 "TcpConnectionPoolSizeTrialWebSocket",
821 256);
822
Hayato Ito3d2778a2025-07-09 02:19:03[diff] [blame]823BASE_FEATURE(kNetTaskScheduler,
824 "NetTaskScheduler",
825 base::FEATURE_DISABLED_BY_DEFAULT);
826BASE_FEATURE_PARAM(bool,
827 kNetTaskSchedulerHttpProxyConnectJob,
828 &kNetTaskScheduler,
829 "http_proxy_connect_job",
830 false);
831BASE_FEATURE_PARAM(bool,
832 kNetTaskSchedulerHttpStreamFactoryJob,
833 &kNetTaskScheduler,
834 "http_stream_factory_job",
835 false);
836BASE_FEATURE_PARAM(bool,
837 kNetTaskSchedulerHttpStreamFactoryJobController,
838 &kNetTaskScheduler,
839 "http_stream_factory_job_controller",
840 false);
841BASE_FEATURE_PARAM(bool,
842 kNetTaskSchedulerURLRequestErrorJob,
843 &kNetTaskScheduler,
844 "url_request_error_job",
845 false);
846BASE_FEATURE_PARAM(bool,
847 kNetTaskSchedulerURLRequestHttpJob,
848 &kNetTaskScheduler,
849 "url_request_http_job",
850 false);
851BASE_FEATURE_PARAM(bool,
852 kNetTaskSchedulerURLRequestJob,
853 &kNetTaskScheduler,
854 "url_request_job",
855 false);
856BASE_FEATURE_PARAM(bool,
857 kNetTaskSchedulerURLRequestRedirectJob,
858 &kNetTaskScheduler,
859 "url_request_redirect_job",
860 false);
861
Tsuyoshi Horo4f516be2022-06-14 11:53:13[diff] [blame]862} // namespace net::features