• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2018 The Chromium Authors
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"
6 
7 #include <vector>
8 
9 #include "base/feature_list.h"
10 #include "build/build_config.h"
11 #include "net/base/cronet_buildflags.h"
12 #include "net/net_buildflags.h"
13 
14 namespace net::features {
15 
16 BASE_FEATURE(kAlpsForHttp2, "AlpsForHttp2", base::FEATURE_ENABLED_BY_DEFAULT);
17 
18 BASE_FEATURE(kAvoidH2Reprioritization,
19              "AvoidH2Reprioritization",
20              base::FEATURE_DISABLED_BY_DEFAULT);
21 
22 BASE_FEATURE(kCapReferrerToOriginOnCrossOrigin,
23              "CapReferrerToOriginOnCrossOrigin",
24              base::FEATURE_DISABLED_BY_DEFAULT);
25 
26 BASE_FEATURE(kAsyncDns,
27              "AsyncDns",
28 #if BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_MAC) || BUILDFLAG(IS_ANDROID) || \
29     BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX)
30              base::FEATURE_ENABLED_BY_DEFAULT
31 #else
32              base::FEATURE_DISABLED_BY_DEFAULT
33 #endif
34 );
35 
36 BASE_FEATURE(kDnsTransactionDynamicTimeouts,
37              "DnsTransactionDynamicTimeouts",
38              base::FEATURE_DISABLED_BY_DEFAULT);
39 
40 const base::FeatureParam<double> kDnsTransactionTimeoutMultiplier{
41     &kDnsTransactionDynamicTimeouts, "DnsTransactionTimeoutMultiplier", 7.5};
42 
43 const base::FeatureParam<base::TimeDelta> kDnsMinTransactionTimeout{
44     &kDnsTransactionDynamicTimeouts, "DnsMinTransactionTimeout",
45     base::Seconds(12)};
46 
47 BASE_FEATURE(kUseDnsHttpsSvcb,
48              "UseDnsHttpsSvcb",
49              base::FEATURE_ENABLED_BY_DEFAULT);
50 
51 const base::FeatureParam<bool> kUseDnsHttpsSvcbEnforceSecureResponse{
52     &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbEnforceSecureResponse", false};
53 
54 const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbInsecureExtraTimeMax{
55     &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbInsecureExtraTimeMax",
56     base::Milliseconds(50)};
57 
58 const base::FeatureParam<int> kUseDnsHttpsSvcbInsecureExtraTimePercent{
59     &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbInsecureExtraTimePercent", 20};
60 
61 const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbInsecureExtraTimeMin{
62     &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbInsecureExtraTimeMin",
63     base::Milliseconds(5)};
64 
65 const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbSecureExtraTimeMax{
66     &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbSecureExtraTimeMax",
67     base::Milliseconds(50)};
68 
69 const base::FeatureParam<int> kUseDnsHttpsSvcbSecureExtraTimePercent{
70     &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbSecureExtraTimePercent", 20};
71 
72 const base::FeatureParam<base::TimeDelta> kUseDnsHttpsSvcbSecureExtraTimeMin{
73     &kUseDnsHttpsSvcb, "UseDnsHttpsSvcbSecureExtraTimeMin",
74     base::Milliseconds(5)};
75 
76 BASE_FEATURE(kUseDnsHttpsSvcbAlpn,
77              "UseDnsHttpsSvcbAlpn",
78              base::FEATURE_ENABLED_BY_DEFAULT);
79 
80 BASE_FEATURE(kUseHostResolverCache,
81              "UseHostResolverCache",
82              base::FEATURE_DISABLED_BY_DEFAULT);
83 
84 BASE_FEATURE(kHappyEyeballsV3,
85              "HappyEyeballsV3",
86              base::FEATURE_DISABLED_BY_DEFAULT);
87 
88 const base::FeatureParam<int> kAlternativePortForGloballyReachableCheck{
89     &kUseAlternativePortForGloballyReachableCheck,
90     "AlternativePortForGloballyReachableCheck", 443};
91 
92 BASE_FEATURE(kUseAlternativePortForGloballyReachableCheck,
93              "UseAlternativePortForGloballyReachableCheck",
94              base::FEATURE_DISABLED_BY_DEFAULT);
95 
96 BASE_FEATURE(kEnableIPv6ReachabilityOverride,
97              "EnableIPv6ReachabilityOverride",
98              base::FEATURE_DISABLED_BY_DEFAULT);
99 
100 BASE_FEATURE(kEnableTLS13EarlyData,
101              "EnableTLS13EarlyData",
102              base::FEATURE_DISABLED_BY_DEFAULT);
103 
104 BASE_FEATURE(kNetworkQualityEstimator,
105              "NetworkQualityEstimator",
106              base::FEATURE_DISABLED_BY_DEFAULT);
107 
108 const base::FeatureParam<int> kRecentHTTPThresholdInSeconds{
109     &kNetworkQualityEstimator, "RecentHTTPThresholdInSeconds", -1};
110 const base::FeatureParam<int> kRecentTransportThresholdInSeconds{
111     &kNetworkQualityEstimator, "RecentTransportThresholdInSeconds", -1};
112 const base::FeatureParam<int> kRecentEndToEndThresholdInSeconds{
113     &kNetworkQualityEstimator, "RecentEndToEndThresholdInSeconds", -1};
114 const base::FeatureParam<int> kCountNewObservationsReceivedComputeEct{
115     &kNetworkQualityEstimator, "CountNewObservationsReceivedComputeEct", 50};
116 const base::FeatureParam<int> kObservationBufferSize{
117     &kNetworkQualityEstimator, "ObservationBufferSize", 300};
118 const base::FeatureParam<base::TimeDelta>
119     kEffectiveConnectionTypeRecomputationInterval{
120         &kNetworkQualityEstimator,
121         "EffectiveConnectionTypeRecomputationInterval", base::Seconds(10)};
122 
123 BASE_FEATURE(kSplitCacheByIncludeCredentials,
124              "SplitCacheByIncludeCredentials",
125              base::FEATURE_DISABLED_BY_DEFAULT);
126 
127 BASE_FEATURE(kSplitCacheByNetworkIsolationKey,
128              "SplitCacheByNetworkIsolationKey",
129              base::FEATURE_DISABLED_BY_DEFAULT);
130 
131 BASE_FEATURE(kSplitCacheByCrossSiteMainFrameNavigationBoolean,
132              "SplitCacheByCrossSiteMainFrameNavigationBoolean",
133              base::FEATURE_DISABLED_BY_DEFAULT);
134 
135 BASE_FEATURE(kSplitCacheByMainFrameNavigationInitiator,
136              "SplitCacheByMainFrameNavigationInitiator",
137              base::FEATURE_DISABLED_BY_DEFAULT);
138 
139 BASE_FEATURE(kSplitCacheByNavigationInitiator,
140              "SplitCacheByNavigationInitiator",
141              base::FEATURE_DISABLED_BY_DEFAULT);
142 
143 BASE_FEATURE(kHttpCacheKeyingExperimentControlGroup2024,
144              "HttpCacheKeyingExperimentControlGroup2024",
145              base::FEATURE_DISABLED_BY_DEFAULT);
146 
147 BASE_FEATURE(kSplitCodeCacheByNetworkIsolationKey,
148              "SplitCodeCacheByNetworkIsolationKey",
149              base::FEATURE_DISABLED_BY_DEFAULT);
150 
151 BASE_FEATURE(kPartitionConnectionsByNetworkIsolationKey,
152              "PartitionConnectionsByNetworkIsolationKey",
153              base::FEATURE_DISABLED_BY_DEFAULT);
154 
155 BASE_FEATURE(kPostQuantumKyber,
156              "PostQuantumKyber",
157              base::FEATURE_ENABLED_BY_DEFAULT);
158 
159 BASE_FEATURE(kUseMLKEM, "UseMLKEM", base::FEATURE_ENABLED_BY_DEFAULT);
160 
161 BASE_FEATURE(kNetUnusedIdleSocketTimeout,
162              "NetUnusedIdleSocketTimeout",
163              base::FEATURE_DISABLED_BY_DEFAULT);
164 
165 BASE_FEATURE(kShortLaxAllowUnsafeThreshold,
166              "ShortLaxAllowUnsafeThreshold",
167              base::FEATURE_DISABLED_BY_DEFAULT);
168 
169 BASE_FEATURE(kSameSiteDefaultChecksMethodRigorously,
170              "SameSiteDefaultChecksMethodRigorously",
171              base::FEATURE_DISABLED_BY_DEFAULT);
172 
173 BASE_FEATURE(kSchemefulSameSite,
174              "SchemefulSameSite",
175              base::FEATURE_ENABLED_BY_DEFAULT);
176 
177 BASE_FEATURE(kLimitOpenUDPSockets,
178              "LimitOpenUDPSockets",
179              base::FEATURE_ENABLED_BY_DEFAULT);
180 
181 extern const base::FeatureParam<int> kLimitOpenUDPSocketsMax(
182     &kLimitOpenUDPSockets,
183     "LimitOpenUDPSocketsMax",
184     6000);
185 
186 BASE_FEATURE(kTimeoutTcpConnectAttempt,
187              "TimeoutTcpConnectAttempt",
188              base::FEATURE_DISABLED_BY_DEFAULT);
189 
190 extern const base::FeatureParam<double> kTimeoutTcpConnectAttemptRTTMultiplier(
191     &kTimeoutTcpConnectAttempt,
192     "TimeoutTcpConnectAttemptRTTMultiplier",
193     5.0);
194 
195 extern const base::FeatureParam<base::TimeDelta> kTimeoutTcpConnectAttemptMin(
196     &kTimeoutTcpConnectAttempt,
197     "TimeoutTcpConnectAttemptMin",
198     base::Seconds(8));
199 
200 extern const base::FeatureParam<base::TimeDelta> kTimeoutTcpConnectAttemptMax(
201     &kTimeoutTcpConnectAttempt,
202     "TimeoutTcpConnectAttemptMax",
203     base::Seconds(30));
204 
205 #if BUILDFLAG(ENABLE_REPORTING)
206 BASE_FEATURE(kDocumentReporting,
207              "DocumentReporting",
208              base::FEATURE_ENABLED_BY_DEFAULT);
209 #endif  // BUILDFLAG(ENABLE_REPORTING)
210 
211 BASE_FEATURE(kCookieSameSiteConsidersRedirectChain,
212              "CookieSameSiteConsidersRedirectChain",
213              base::FEATURE_DISABLED_BY_DEFAULT);
214 
215 BASE_FEATURE(kAllowSameSiteNoneCookiesInSandbox,
216              "AllowSameSiteNoneCookiesInSandbox",
217              base::FEATURE_DISABLED_BY_DEFAULT);
218 
219 BASE_FEATURE(kWaitForFirstPartySetsInit,
220              "WaitForFirstPartySetsInit",
221              base::FEATURE_DISABLED_BY_DEFAULT);
222 
223 // Controls the maximum time duration an outermost frame navigation should be
224 // deferred by RWS initialization.
225 extern const base::FeatureParam<base::TimeDelta>
226     kWaitForFirstPartySetsInitNavigationThrottleTimeout{
227         &kWaitForFirstPartySetsInit,
228         "kWaitForFirstPartySetsInitNavigationThrottleTimeout",
229         base::Seconds(0)};
230 
231 BASE_FEATURE(kAncestorChainBitEnabledInPartitionedCookies,
232              "AncestorChainBitEnabledInPartitionedCookies",
233              base::FEATURE_ENABLED_BY_DEFAULT);
234 
235 BASE_FEATURE(kStaticKeyPinningEnforcement,
236              "StaticKeyPinningEnforcement",
237              base::FEATURE_ENABLED_BY_DEFAULT);
238 
239 BASE_FEATURE(kCookieDomainRejectNonASCII,
240              "CookieDomainRejectNonASCII",
241              base::FEATURE_DISABLED_BY_DEFAULT);
242 
243 // Enables partitioning of third party storage (IndexedDB, CacheStorage, etc.)
244 // by the top level site to reduce fingerprinting.
245 BASE_FEATURE(kThirdPartyStoragePartitioning,
246              "ThirdPartyStoragePartitioning",
247              base::FEATURE_ENABLED_BY_DEFAULT);
248 
249 BASE_FEATURE(kTopLevelTpcdOriginTrial,
250              "TopLevelTpcdOriginTrial",
251              base::FEATURE_ENABLED_BY_DEFAULT);
252 
253 BASE_FEATURE(kTpcdTrialSettings,
254              "TpcdSupportSettings",
255              base::FEATURE_ENABLED_BY_DEFAULT);
256 
257 BASE_FEATURE(kTopLevelTpcdTrialSettings,
258              "TopLevelTpcdSupportSettings",
259              base::FEATURE_ENABLED_BY_DEFAULT);
260 
261 BASE_FEATURE(kTpcdMetadataGrants,
262              "TpcdMetadataGrants",
263              base::FEATURE_ENABLED_BY_DEFAULT);
264 
265 BASE_FEATURE(kTpcdMetadataStageControl,
266              "TpcdMetadataStageControl",
267              base::FEATURE_ENABLED_BY_DEFAULT);
268 
269 BASE_FEATURE(kAlpsParsing, "AlpsParsing", base::FEATURE_ENABLED_BY_DEFAULT);
270 
271 BASE_FEATURE(kAlpsClientHintParsing,
272              "AlpsClientHintParsing",
273              base::FEATURE_ENABLED_BY_DEFAULT);
274 
275 BASE_FEATURE(kShouldKillSessionOnAcceptChMalformed,
276              "ShouldKillSessionOnAcceptChMalformed",
277              base::FEATURE_DISABLED_BY_DEFAULT);
278 
279 BASE_FEATURE(kEnableWebsocketsOverHttp3,
280              "EnableWebsocketsOverHttp3",
281              base::FEATURE_DISABLED_BY_DEFAULT);
282 
283 #if BUILDFLAG(IS_WIN)
284 // Disabled because of https://crbug.com/1489696.
285 BASE_FEATURE(kEnableGetNetworkConnectivityHintAPI,
286              "EnableGetNetworkConnectivityHintAPI",
287              base::FEATURE_DISABLED_BY_DEFAULT);
288 
289 BASE_FEATURE(kEnableTcpPortRandomization,
290              "EnableTcpPortRandomization",
291              base::FEATURE_DISABLED_BY_DEFAULT);
292 
293 BASE_FEATURE(kTcpSocketIoCompletionPortWin,
294              "TcpSocketIoCompletionPortWin",
295              base::FEATURE_DISABLED_BY_DEFAULT);
296 #endif
297 
298 BASE_FEATURE(kAvoidEntryCreationForNoStore,
299              "AvoidEntryCreationForNoStore",
300              base::FEATURE_DISABLED_BY_DEFAULT);
301 const base::FeatureParam<int> kAvoidEntryCreationForNoStoreCacheSize{
302     &kAvoidEntryCreationForNoStore, "AvoidEntryCreationForNoStoreCacheSize",
303     1000};
304 
305 // Prefetch to follow normal semantics instead of 5-minute rule
306 // https://crbug.com/1345207
307 BASE_FEATURE(kPrefetchFollowsNormalCacheSemantics,
308              "PrefetchFollowsNormalCacheSemantics",
309              base::FEATURE_ENABLED_BY_DEFAULT);
310 
311 // A flag for new Kerberos feature, that suggests new UI
312 // when Kerberos authentication in browser fails on ChromeOS.
313 // b/260522530
314 #if BUILDFLAG(IS_CHROMEOS)
315 BASE_FEATURE(kKerberosInBrowserRedirect,
316              "KerberosInBrowserRedirect",
317              base::FEATURE_ENABLED_BY_DEFAULT);
318 #endif
319 
320 // A flag to use asynchronous session creation for new QUIC sessions.
321 BASE_FEATURE(kAsyncQuicSession,
322              "AsyncQuicSession",
323 #if BUILDFLAG(IS_WIN)
324              base::FEATURE_ENABLED_BY_DEFAULT);
325 #else
326              base::FEATURE_DISABLED_BY_DEFAULT);
327 #endif
328 
329 // A flag to make multiport context creation asynchronous.
330 BASE_FEATURE(kAsyncMultiPortPath,
331              "AsyncMultiPortPath",
332 #if !BUILDFLAG(CRONET_BUILD) && (BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID))
333              base::FEATURE_ENABLED_BY_DEFAULT);
334 #else
335              base::FEATURE_DISABLED_BY_DEFAULT);
336 #endif
337 
338 // IP protection experiment configuration settings
339 BASE_FEATURE(kEnableIpProtectionProxy,
340              "EnableIpPrivacyProxy",
341              base::FEATURE_DISABLED_BY_DEFAULT);
342 
343 const base::FeatureParam<std::string> kIpPrivacyTokenServer{
344     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyTokenServer",
345     /*default_value=*/"https://prod.ipprotectionauth.goog"};
346 
347 const base::FeatureParam<std::string> kIpPrivacyTokenServerGetInitialDataPath{
348     &kEnableIpProtectionProxy,
349     /*name=*/"IpPrivacyTokenServerGetInitialDataPath",
350     /*default_value=*/"/v1/ipblinding/getInitialData"};
351 
352 const base::FeatureParam<std::string> kIpPrivacyTokenServerGetTokensPath{
353     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyTokenServerGetTokensPath",
354     /*default_value=*/"/v1/ipblinding/auth"};
355 
356 const base::FeatureParam<std::string> kIpPrivacyTokenServerGetProxyConfigPath{
357     &kEnableIpProtectionProxy,
358     /*name=*/"IpPrivacyTokenServerGetProxyConfigPath",
359     /*default_value=*/"/v1/ipblinding/getProxyConfig"};
360 
361 const base::FeatureParam<int> kIpPrivacyAuthTokenCacheBatchSize{
362     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyAuthTokenCacheBatchSize",
363     /*default_value=*/64};
364 
365 const base::FeatureParam<int> kIpPrivacyAuthTokenCacheLowWaterMark{
366     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyAuthTokenCacheLowWaterMark",
367     /*default_value=*/16};
368 
369 const base::FeatureParam<base::TimeDelta> kIpPrivacyProxyListFetchInterval{
370     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyListFetchInterval",
371     /*default_value=*/base::Hours(1)};
372 
373 const base::FeatureParam<base::TimeDelta> kIpPrivacyProxyListMinFetchInterval{
374     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyMinListFetchInterval",
375     /*default_value=*/base::Minutes(1)};
376 
377 const base::FeatureParam<base::TimeDelta> kIpPrivacyProxyListFetchIntervalFuzz{
378     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyListFetchIntervalFuzz",
379     /*default_value=*/base::Minutes(30)};
380 
381 const base::FeatureParam<bool> kIpPrivacyDirectOnly{
382     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyDirectOnly",
383     /*default_value=*/false};
384 
385 const base::FeatureParam<bool> kIpPrivacyIncludeOAuthTokenInGetProxyConfig{
386     &kEnableIpProtectionProxy,
387     /*name=*/"IpPrivacyIncludeOAuthTokenInGetProxyConfig",
388     /*default_value=*/false};
389 
390 const base::FeatureParam<std::string> kIpPrivacyProxyAHostnameOverride{
391     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyAHostnameOverride",
392     /*default_value=*/""};
393 
394 const base::FeatureParam<std::string> kIpPrivacyProxyBHostnameOverride{
395     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyProxyBHostnameOverride",
396     /*default_value=*/""};
397 
398 const base::FeatureParam<bool> kIpPrivacyAddHeaderToProxiedRequests{
399     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyAddHeaderToProxiedRequests",
400     /*default_value=*/false};
401 
402 const base::FeatureParam<base::TimeDelta> kIpPrivacyExpirationFuzz{
403     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyExpirationFuzz",
404     /*default_value=*/base::Minutes(15)};
405 
406 const base::FeatureParam<base::TimeDelta>
407     kIpPrivacyTryGetAuthTokensNotEligibleBackoff{
408         &kEnableIpProtectionProxy,
409         /*name=*/"IpPrivacyTryGetAuthTokensNotEligibleBackoff",
410         /*default_value=*/base::Days(1)};
411 
412 const base::FeatureParam<base::TimeDelta>
413     kIpPrivacyTryGetAuthTokensTransientBackoff{
414         &kEnableIpProtectionProxy,
415         /*name=*/"IpPrivacyTryGetAuthTokensTransientBackoff",
416         /*default_value=*/base::Seconds(5)};
417 
418 const base::FeatureParam<base::TimeDelta> kIpPrivacyTryGetAuthTokensBugBackoff{
419     &kEnableIpProtectionProxy, /*name=*/"IpPrivacyTryGetAuthTokensBugBackoff",
420     /*default_value=*/base::Minutes(10)};
421 
422 const base::FeatureParam<bool> kIpPrivacyRestrictTopLevelSiteSchemes{
423     &kEnableIpProtectionProxy,
424     /*name=*/"IpPrivacyRestrictTopLevelSiteSchemes",
425     /*default_value=*/true};
426 
427 const base::FeatureParam<bool> kIpPrivacyUseQuicProxies{
428     &kEnableIpProtectionProxy,
429     /*name=*/"IpPrivacyUseQuicProxies",
430     /*default_value=*/false};
431 
432 const base::FeatureParam<bool> kIpPrivacyUseQuicProxiesOnly{
433     &kEnableIpProtectionProxy,
434     /*name=*/"IpPrivacyUseQuicProxiesOnly",
435     /*default_value=*/false};
436 
437 const base::FeatureParam<bool> kIpPrivacyUseSingleProxy{
438     &kEnableIpProtectionProxy,
439     /*name=*/"IpPrivacyUseSingleProxy",
440     /*default_value=*/false};
441 
442 const base::FeatureParam<std::string> kIpPrivacyAlwaysProxy{
443     &kEnableIpProtectionProxy,
444     /*name=*/"IpPrivacyAlwaysProxy",
445     /*default_value=*/""};
446 
447 const base::FeatureParam<bool> kIpPrivacyFallbackToDirect{
448     &kEnableIpProtectionProxy,
449     /*name=*/"IpPrivacyFallbackToDirect",
450     /*default_value=*/true};
451 
452 const base::FeatureParam<int> kIpPrivacyDebugExperimentArm{
453     &kEnableIpProtectionProxy,
454     /*name=*/"IpPrivacyDebugExperimentArm",
455     /*default_value=*/0};
456 
457 const base::FeatureParam<bool> kIpPrivacyCacheTokensByGeo{
458     &kEnableIpProtectionProxy,
459     /*name=*/"IpPrivacyCacheTokensByGeo",
460     /*default_value=*/false};
461 
462 const base::FeatureParam<bool> kIpPrivacyAlwaysCreateCore{
463     &kEnableIpProtectionProxy,
464     /*name=*/"IpPrivacyAlwaysCreateCore",
465     /*default_value=*/false};
466 
467 const base::FeatureParam<bool> kIpPrivacyOnlyInIncognito{
468     &kEnableIpProtectionProxy,
469     /*name=*/"IpPrivacyOnlyInIncognito",
470     /*default_value=*/false};
471 
472 // Network-change migration requires NetworkHandle support, which are currently
473 // only supported on Android (see
474 // NetworkChangeNotifier::AreNetworkHandlesSupported).
475 #if BUILDFLAG(IS_ANDROID)
476 inline constexpr auto kMigrateSessionsOnNetworkChangeV2Default =
477     base::FEATURE_ENABLED_BY_DEFAULT;
478 #else   // !BUILDFLAG(IS_ANDROID)
479 inline constexpr auto kMigrateSessionsOnNetworkChangeV2Default =
480     base::FEATURE_DISABLED_BY_DEFAULT;
481 #endif  // BUILDFLAG(IS_ANDROID)
482 BASE_FEATURE(kMigrateSessionsOnNetworkChangeV2,
483              "MigrateSessionsOnNetworkChangeV2",
484              kMigrateSessionsOnNetworkChangeV2Default);
485 
486 BASE_FEATURE(kDisableBlackholeOnNoNewNetwork,
487              "DisableBlackHoleOnNoNewNetwork",
488              base::FEATURE_DISABLED_BY_DEFAULT);
489 
490 #if BUILDFLAG(IS_LINUX)
491 BASE_FEATURE(kAddressTrackerLinuxIsProxied,
492              "AddressTrackerLinuxIsProxied",
493              base::FEATURE_ENABLED_BY_DEFAULT);
494 #endif  // BUILDFLAG(IS_LINUX)
495 
496 // Enables binding of cookies to the port that originally set them by default.
497 BASE_FEATURE(kEnablePortBoundCookies,
498              "EnablePortBoundCookies",
499              base::FEATURE_DISABLED_BY_DEFAULT);
500 
501 // Enables binding of cookies to the scheme that originally set them.
502 NET_EXPORT BASE_DECLARE_FEATURE(kEnableSchemeBoundCookies);
503 BASE_FEATURE(kEnableSchemeBoundCookies,
504              "EnableSchemeBoundCookies",
505              base::FEATURE_DISABLED_BY_DEFAULT);
506 
507 BASE_FEATURE(kTimeLimitedInsecureCookies,
508              "TimeLimitedInsecureCookies",
509              base::FEATURE_DISABLED_BY_DEFAULT);
510 
511 // Enable third-party cookie blocking from the command line.
512 BASE_FEATURE(kForceThirdPartyCookieBlocking,
513              "ForceThirdPartyCookieBlockingEnabled",
514              base::FEATURE_DISABLED_BY_DEFAULT);
515 
516 BASE_FEATURE(kEnableEarlyHintsOnHttp11,
517              "EnableEarlyHintsOnHttp11",
518              base::FEATURE_DISABLED_BY_DEFAULT);
519 
520 BASE_FEATURE(kEnableWebTransportDraft07,
521              "EnableWebTransportDraft07",
522              base::FEATURE_DISABLED_BY_DEFAULT);
523 
524 // When enabled, partitioned storage will be allowed even if third-party cookies
525 // are disabled by default. Partitioned storage will not be allowed if
526 // third-party cookies are disabled due to a specific rule.
527 BASE_FEATURE(kThirdPartyPartitionedStorageAllowedByDefault,
528              "ThirdPartyPartitionedStorageAllowedByDefault",
529              base::FEATURE_ENABLED_BY_DEFAULT);
530 
531 BASE_FEATURE(kSpdyHeadersToHttpResponseUseBuilder,
532              "SpdyHeadersToHttpResponseUseBuilder",
533              base::FEATURE_DISABLED_BY_DEFAULT);
534 
535 BASE_FEATURE(kReportEcn, "ReportEcn", base::FEATURE_DISABLED_BY_DEFAULT);
536 
537 BASE_FEATURE(kUseNewAlpsCodepointHttp2,
538              "UseNewAlpsCodepointHttp2",
539              base::FEATURE_DISABLED_BY_DEFAULT);
540 
541 BASE_FEATURE(kUseNewAlpsCodepointQUIC,
542              "UseNewAlpsCodepointQUIC",
543              base::FEATURE_DISABLED_BY_DEFAULT);
544 
545 BASE_FEATURE(kTreatHTTPExpiresHeaderValueZeroAsExpired,
546              "TreatHTTPExpiresHeaderValueZeroAsExpired",
547              base::FEATURE_ENABLED_BY_DEFAULT);
548 
549 BASE_FEATURE(kTruncateBodyToContentLength,
550              "TruncateBodyToContentLength",
551              base::FEATURE_ENABLED_BY_DEFAULT);
552 
553 #if BUILDFLAG(IS_MAC)
554 BASE_FEATURE(kReduceIPAddressChangeNotification,
555              "ReduceIPAddressChangeNotification",
556              base::FEATURE_ENABLED_BY_DEFAULT);
557 #endif  // BUILDFLAG(IS_MAC)
558 
559 BASE_FEATURE(kDeviceBoundSessions,
560              "DeviceBoundSessions",
561              base::FEATURE_DISABLED_BY_DEFAULT);
562 BASE_FEATURE(kPersistDeviceBoundSessions,
563              "PersistDeviceBoundSessions",
564              base::FEATURE_DISABLED_BY_DEFAULT);
565 
566 BASE_FEATURE(kStoreConnectionSubtype,
567              "StoreConnectionSubtype",
568              base::FEATURE_ENABLED_BY_DEFAULT);
569 
570 BASE_FEATURE(kPartitionProxyChains,
571              "PartitionProxyChains",
572              base::FEATURE_ENABLED_BY_DEFAULT);
573 
574 BASE_FEATURE(kSpdySessionForProxyAdditionalChecks,
575              "SpdySessionForProxyAdditionalChecks",
576              base::FEATURE_ENABLED_BY_DEFAULT);
577 
578 BASE_FEATURE(kCompressionDictionaryTransportOverHttp1,
579              "CompressionDictionaryTransportOverHttp1",
580              base::FEATURE_ENABLED_BY_DEFAULT);
581 
582 BASE_FEATURE(kCompressionDictionaryTransportOverHttp2,
583              "CompressionDictionaryTransportOverHttp2",
584              base::FEATURE_ENABLED_BY_DEFAULT);
585 
586 BASE_FEATURE(kCompressionDictionaryTransportRequireKnownRootCert,
587              "CompressionDictionaryTransportRequireKnownRootCert",
588              base::FEATURE_ENABLED_BY_DEFAULT);
589 
590 BASE_FEATURE(kReportingApiEnableEnterpriseCookieIssues,
591              "ReportingApiEnableEnterpriseCookieIssues",
592              base::FEATURE_DISABLED_BY_DEFAULT);
593 
594 BASE_FEATURE(kOptimizeParsingDataUrls,
595              "OptimizeParsingDataUrls",
596              base::FEATURE_ENABLED_BY_DEFAULT);
597 
598 // TODO(crbug.com/347047841): Remove this flag when we branch for M131 or later,
599 // if we haven't had to turn this off.
600 BASE_FEATURE(kLegacyPKCS1ForTLS13,
601              "LegacyPKCS1ForTLS13",
602              base::FEATURE_ENABLED_BY_DEFAULT);
603 
604 BASE_FEATURE(kKeepWhitespaceForDataUrls,
605              "KeepWhitespaceForDataUrls",
606              base::FEATURE_ENABLED_BY_DEFAULT);
607 
608 BASE_FEATURE(kNoVarySearchIgnoreUnrecognizedKeys,
609              "NoVarySearchIgnoreUnrecognizedKeys",
610              base::FEATURE_ENABLED_BY_DEFAULT);
611 
612 BASE_FEATURE(kEncryptedAndPlaintextValuesAreInvalid,
613              "EncryptedAndPlaintextValuesAreInvalid",
614              base::FEATURE_ENABLED_BY_DEFAULT);
615 
616 BASE_FEATURE(kEnableStaticCTAPIEnforcement,
617              "EnableStaticCTAPIEnforcement",
618              base::FEATURE_ENABLED_BY_DEFAULT);
619 
620 BASE_FEATURE(kDiskCacheBackendExperiment,
621              "DiskCacheBackendExperiment",
622              base::FEATURE_DISABLED_BY_DEFAULT);
623 constexpr base::FeatureParam<DiskCacheBackend>::Option
624     kDiskCacheBackendOptions[] = {
625         {DiskCacheBackend::kSimple, "simple"},
626         {DiskCacheBackend::kBlockfile, "blockfile"},
627 };
628 const base::FeatureParam<DiskCacheBackend> kDiskCacheBackendParam{
629     &kDiskCacheBackendExperiment, "backend", DiskCacheBackend::kBlockfile,
630     &kDiskCacheBackendOptions};
631 
632 BASE_FEATURE(kIgnoreHSTSForLocalhost,
633              "IgnoreHSTSForLocalhost",
634              base::FEATURE_ENABLED_BY_DEFAULT);
635 
636 BASE_FEATURE(kSimpleCachePrioritizedCaching,
637              "SimpleCachePrioritizedCaching",
638              base::FEATURE_DISABLED_BY_DEFAULT);
639 
640 const base::FeatureParam<int>
641     kSimpleCachePrioritizedCachingPrioritizationFactor{
642         &kSimpleCachePrioritizedCaching,
643         /*name=*/"SimpleCachePrioritizedCachingPrioritizationFactor",
644         /*default_value=*/10};
645 
646 const base::FeatureParam<base::TimeDelta>
647     kSimpleCachePrioritizedCachingPrioritizationPeriod{
648         &kSimpleCachePrioritizedCaching,
649         /*name=*/"SimpleCachePrioritizedCachingPrioritizationPeriod",
650         /*default_value=*/base::Days(1)};
651 
652 #if BUILDFLAG(USE_NSS_CERTS)
653 // TODO(crbug.com/40928765): Remove this flag after a few milestones.
654 BASE_FEATURE(kNewClientCertPathBuilding,
655              "NewClientCertPathBuilding",
656              base::FEATURE_ENABLED_BY_DEFAULT);
657 #endif  // BUILDFLAG(USE_NSS_CERTS)
658 
659 }  // namespace net::features
660