Skip to content

GitLab

T
tangled
Commit ce6b4f9e authored by Bence Béky's avatar Bence Béky Committed by Commit Bot
Browse files
Options

Remove obsolete flags from quic_flags_list.h 

Remove two obsolete flags: FLAGS_quic_bbr_rtt_variation_weight and
FLAGS_quic_ietf_draft_version.

Every remaining flag is a reloadable flag or a restart flag, all
Boolean.  Remove type argument.

Change-Id: I0b9d6db33b82968c05aa8025d86921f1df7a29b2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2502751Reviewed-by: default avatarDavid Schinazi <dschinazi@chromium.org>
Reviewed-by: default avatarVictor Vasiliev <vasilvv@chromium.org>
Commit-Queue: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#821330}
parent 46d03267
Show whitespace changes
Inline Side-by-side
Showing with 80 additions and 153 deletions
net/quic/platform/impl/quic_flags_impl.cc
View file @ ce6b4f9e
......@@ -21,7 +21,7 @@
#include "build/build_config.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#define QUIC_FLAG(type, flag, value) type flag = value;
#define QUIC_FLAG(flag, value) bool flag = value;
#include "net/quic/quic_flags_list.h"
#undef QUIC_FLAG
......@@ -304,9 +304,9 @@ void SetQuicFlagByName_int64_t(int64_t* flag, const std::string& value) {
} // namespace
void SetQuicFlagByName(const std::string& flag_name, const std::string& value) {
#define QUIC_FLAG(type, flag, default_value) \
#define QUIC_FLAG(flag, default_value) \
if (flag_name == #flag) { \
SetQuicFlagByName_##type(&flag, value); \
SetQuicFlagByName_bool(&flag, value); \
return; \
}
#include "net/quic/quic_flags_list.h"
......
net/quic/platform/impl/quic_flags_impl.h
View file @ ce6b4f9e
......@@ -16,7 +16,7 @@
#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#define QUIC_FLAG(type, flag, value) QUIC_EXPORT_PRIVATE extern type flag;
#define QUIC_FLAG(flag, value) QUIC_EXPORT_PRIVATE extern bool flag;
#include "net/quic/quic_flags_list.h"
#undef QUIC_FLAG
......
net/quic/platform/impl/quic_test_impl.cc
View file @ ce6b4f9e
......@@ -8,13 +8,13 @@
#include "base/path_service.h"
QuicFlagSaverImpl::QuicFlagSaverImpl() {
#define QUIC_FLAG(type, flag, value) saved_##flag##_ = flag;
#define QUIC_FLAG(flag, value) saved_##flag##_ = flag;
#include "net/quic/quic_flags_list.h"
#undef QUIC_FLAG
}
QuicFlagSaverImpl::~QuicFlagSaverImpl() {
#define QUIC_FLAG(type, flag, value) flag = saved_##flag##_;
#define QUIC_FLAG(flag, value) flag = saved_##flag##_;
#include "net/quic/quic_flags_list.h"
#undef QUIC_FLAG
}
......
net/quic/platform/impl/quic_test_impl.h
View file @ ce6b4f9e
......@@ -21,7 +21,7 @@ class QuicFlagSaverImpl {
~QuicFlagSaverImpl();
private:
#define QUIC_FLAG(type, flag, value) type saved_##flag##_;
#define QUIC_FLAG(flag, value) bool saved_##flag##_;
#include "net/quic/quic_flags_list.h"
#undef QUIC_FLAG
};
......@@ -30,7 +30,7 @@ class QuicFlagSaverImpl {
class QuicFlagChecker {
public:
QuicFlagChecker() {
#define QUIC_FLAG(type, flag, value) \
#define QUIC_FLAG(flag, value) \
CHECK_EQ(value, flag) \
<< "Flag set to an unexpected value. A prior test is likely " \
<< "setting a flag without using a QuicFlagSaver. Use QuicTest to " \
......
net/quic/quic_flags_list.h
View file @ ce6b4f9e
......@@ -8,407 +8,334 @@
// no-include-guard-because-multiply-included
// NOLINT(build/header_guard)
// This file contains the list of QUIC protocol flags.
// This file contains the list of QUIC reloadable and restart flags.
// If true, require handshake confirmation for QUIC connections, functionally
// disabling 0-rtt handshakes.
// TODO(rtenneti): Enable this flag after CryptoServerTest's are fixed.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_require_handshake_confirmation,
false)
// If greater than zero, mean RTT variation is multiplied by the specified
// factor and added to the congestion window limit.
QUIC_FLAG(double, FLAGS_quic_bbr_rtt_variation_weight, 0.0f)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_require_handshake_confirmation, false)
// When true, defaults to BBR congestion control instead of Cubic.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_default_to_bbr, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr, false)
// If true, use BBRv2 as the default congestion controller.
// Takes precedence over --quic_default_to_bbr.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_default_to_bbr_v2, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr_v2, false)
// When true, set the initial congestion control window from connection options
// in QuicSentPacketManager rather than TcpCubicSenderBytes.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_unified_iw_options, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_unified_iw_options, false)
// If true, QUIC offload pacing when using USPS as egress method.
QUIC_FLAG(bool, FLAGS_quic_restart_flag_quic_offload_pacing_to_usps2, false)
// Mechanism to override version label and ALPN for IETF interop.
QUIC_FLAG(int32_t, FLAGS_quic_ietf_draft_version, 0)
QUIC_FLAG(FLAGS_quic_restart_flag_quic_offload_pacing_to_usps2, false)
// If true, stop resetting ideal_next_packet_send_time_ in pacing sender.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_donot_reset_ideal_next_packet_send_time,
false)
// When the STMP connection option is sent by the client, timestamps in the QUIC
// ACK frame are sent and processed.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_send_timestamps, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_send_timestamps, false)
// If true and using Leto for QUIC shared-key calculations, GFE will react to a
// failure to contact Leto by sending a REJ containing a fallback ServerConfig,
// allowing the client to continue the handshake.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_send_quic_fallback_server_config_on_leto_error,
false)
// If true, GFE will not request private keys when fetching QUIC ServerConfigs
// from Leto.
QUIC_FLAG(bool,
FLAGS_quic_restart_flag_dont_fetch_quic_private_keys_from_leto,
false)
QUIC_FLAG(FLAGS_quic_restart_flag_dont_fetch_quic_private_keys_from_leto, false)
// If true, set burst token to 2 in cwnd bootstrapping experiment.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_conservative_bursts, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_conservative_bursts, false)
// If true, uses conservative cwnd gain and pacing gain.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_conservative_cwnd_and_pacing_gains,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_conservative_cwnd_and_pacing_gains,
false)
// If true, allow client to enable BBRv2 on server via connection option 'B2ON'.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_allow_client_enabled_bbr_v2,
false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_allow_client_enabled_bbr_v2, false)
// If true, disable QUIC version Q043.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_q043, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q043, false)
// If true, disable QUIC version Q046.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_q046, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q046, false)
// If true, disable QUIC version Q050.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_q050, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q050, false)
// A testonly reloadable flag that will always default to false.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_testonly_default_false, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_testonly_default_false, false)
// A testonly reloadable flag that will always default to true.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_testonly_default_true, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_testonly_default_true, true)
// A testonly restart flag that will always default to false.
QUIC_FLAG(bool, FLAGS_quic_restart_flag_quic_testonly_default_false, false)
QUIC_FLAG(FLAGS_quic_restart_flag_quic_testonly_default_false, false)
// A testonly restart flag that will always default to true.
QUIC_FLAG(bool, FLAGS_quic_restart_flag_quic_testonly_default_true, true)
QUIC_FLAG(FLAGS_quic_restart_flag_quic_testonly_default_true, true)
// When true, ensure the ACK delay is never less than the alarm granularity when
// ACK decimation is enabled.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_ack_delay_alarm_granularity,
false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_ack_delay_alarm_granularity, false)
// If true, disable QUIC version h3-27.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_draft_27, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_draft_27, true)
// If true, QUIC BBRv2\'s PROBE_BW mode will not reduce cwnd below
// BDP+ack_height.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_bbr2_avoid_too_low_probe_bw_cwnd,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_avoid_too_low_probe_bw_cwnd,
false)
// When true, the 1RTT and 2RTT connection options decrease the number of round
// trips in BBRv2 STARTUP without a 25% bandwidth increase to 1 or 2 round trips
// respectively.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_bbr2_fewer_startup_round_trips,
false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_fewer_startup_round_trips, false)
// If true, support for IETF QUIC 0-rtt is enabled.
QUIC_FLAG(bool, FLAGS_quic_restart_flag_quic_enable_zero_rtt_for_tls_v2, true)
QUIC_FLAG(FLAGS_quic_restart_flag_quic_enable_zero_rtt_for_tls_v2, true)
// If true, default on PTO which unifies TLP + RTO loss recovery.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_default_on_pto, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_on_pto, false)
// If true, the B2HI connection option limits reduction of inflight_hi to
// (1-Beta)*CWND.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_bbr2_limit_inflight_hi, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_limit_inflight_hi, false)
// If true, disable QUIC version h3-T050.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_t050, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_t050, false)
// If true, default-enable 5RTO blachole detection.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_default_enable_5rto_blackhole_detection2,
true)
// If true, disable QUIC version h3-29.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_draft_29, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_draft_29, false)
// If true, record the received min_ack_delay in transport parameters to QUIC
// config.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_record_received_min_ack_delay,
false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_record_received_min_ack_delay, false)
// If true, disable blackhole detection on server side.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_disable_server_blackhole_detection,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_server_blackhole_detection,
false)
// If true, QUIC will default enable MTU discovery, with a target of 1450 bytes.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_enable_mtu_discovery_at_server,
false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_mtu_discovery_at_server, false)
// If true, while reading an IETF quic packet, start peer migration immediately
// when detecting the existence of any non-probing frame instead of at the end
// of the packet.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_start_peer_migration_earlier,
false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_start_peer_migration_earlier, false)
// If true, neuter initial packet in the coalescer when discarding initial keys.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_neuter_initial_packet_in_coalescer_with_initial_key_discarded,
true)
// If true, convert bytes_left_for_batch_write_ to unsigned int.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_fix_bytes_left_for_batch_write,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_bytes_left_for_batch_write, true)
// If true, add missing connected checks.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_add_missing_connected_checks,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_add_missing_connected_checks, true)
// If true, QuicStream::kDefaultUrgency is 3, otherwise 1.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_http3_new_default_urgency_value,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_http3_new_default_urgency_value, true)
// If true, close connection on packet serialization failures
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_close_connection_on_serialization_failure,
true)
// If true, send PATH_RESPONSE upon receiving PATH_CHALLENGE regardless
// of perspective.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_send_path_response, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_send_path_response, false)
// If true, when switching from BBR to BBR2, use BBR's CWND as the initial CWND.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_copy_bbr_cwnd_to_bbr2, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_copy_bbr_cwnd_to_bbr2, true)
// If true, send the lowest stream ID that can be retried by the client in a
// GOAWAY frame.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_fix_http3_goaway_stream_id,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_http3_goaway_stream_id, true)
// If true, close connection if writer is still blocked when OnCanWrite is
// called.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_close_connection_in_on_can_write_with_blocked_writer,
true)
// If true, include stream information in idle timeout connection close detail.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_add_stream_info_to_idle_close_detail,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_add_stream_info_to_idle_close_detail,
true)
// If true, use IETF QUIC application error codes in STOP_SENDING frames.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_stop_sending_uses_ietf_error_code,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_stop_sending_uses_ietf_error_code,
true)
// If true, QuicSpdySession's destructor won't need to do cleanup.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_clean_up_spdy_session_destructor,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_clean_up_spdy_session_destructor,
true)
// If true, discard INITIAL packet if the key has been dropped.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_discard_initial_packet_with_key_dropped,
true)
// If true, disable QUIC version h3-T051.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_t051, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_t051, false)
// If true, make sure there is pending timer credit when trying to PTO
// retransmit any packets.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_fix_pto_pending_timer_count,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_pto_pending_timer_count, true)
// If true, QUIC connection will pass sent packet information to the debug
// visitor after a packet is recorded as sent in sent packet manager.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_give_sent_packet_to_debug_visitor_after_sent,
true)
// If true, abort async QPACK header decompression in QuicSpdyStream::OnClose().
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_abort_qpack_on_stream_close,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_abort_qpack_on_stream_close, true)
// If true, do not arm PTO for application data until handshake confirmed.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_fix_arm_pto_for_application_data,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_arm_pto_for_application_data,
true)
// If true, cap client suggested initial RTT to 1s if it is longer than 1s.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_cap_large_client_initial_rtt,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_cap_large_client_initial_rtt, true)
// If true, fix a potential out of order sending caused by handshake gets
// confirmed while the coalescer is not empty.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_fix_out_of_order_sending2, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_out_of_order_sending2, true)
// If true, remove processed undecryptable packets.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_fix_undecryptable_packets2,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_undecryptable_packets2, true)
// If true, QUIC BBRv2 will use inflight byte after congestion event to detect
// queuing during PROBE_UP.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_bbr2_use_post_inflight_to_detect_queuing,
true)
// If true, QUIC BBRv2 will use 15% inflight_hi headroom, which is the default
// for TCP.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_bbr2_use_tcp_inflight_hi_headroom,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_use_tcp_inflight_hi_headroom,
true)
// If true, HTTP/3 will treat HTTP/2 specific SETTINGS as error.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_reject_spdy_settings, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_reject_spdy_settings, true)
// If true, discard 0-RTT keys after installing 1-RTT keys on the client side.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_postpone_discarding_zero_rtt_keys,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_postpone_discarding_zero_rtt_keys,
true)
// If true, for IETF QUIC, uses 2 * RTTVAR when calculating PTO delay.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_default_to_2_rttvar, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_2_rttvar, true)
// Deallocate data in QuicMessageFrame right after the corresponding packet is
// sent.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_deallocate_message_right_after_sent,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_deallocate_message_right_after_sent,
true)
// If true, drop initial keys at the end of writing and unify the fixes for
// missing initial keys.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_fix_missing_initial_keys2, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_missing_initial_keys2, true)
// If true, check whether framer has the right key before writing data.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_check_keys_before_writing, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_check_keys_before_writing, true)
// If true, received error codes larger than QUIC_LAST_ERROR are preserved.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_do_not_clip_received_error_code,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_do_not_clip_received_error_code,
false)
// If true, HTTP/3 sesions will report error and close connection upon receiving
// HTTP/2 only frames.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_reject_spdy_frames, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_reject_spdy_frames, false)
// If true, QuicConnection will initialize its self address to the self address
// of the first received packet, for all server connections and client
// connections that know its own address.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_connection_set_initial_self_address,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_connection_set_initial_self_address,
true)
// If true, let QUIC connection handle PINGs instead of going through session.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_let_connection_handle_pings,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_let_connection_handle_pings, true)
// If true, BBRv2 will 1) change the default STARTUP and DRAIN cwnd gain to 2.0,
// and 2) change the meaning of connection option BBQ2 to use 2.885 for STARTUP
// and DRAIN cwnd gain.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_bbr2_flip_bbq2, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_flip_bbq2, true)
// If true, use http2::HuffmanEncodeFast() instead of HuffmanEncode() and
// eliminate one string copy for QPACK encoding used in IETF QUIC.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_use_fast_huffman_encoder, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_fast_huffman_encoder, true)
// When true, QUIC+TLS versions will support key updates.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_key_update_supported, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_key_update_supported, false)
// If true, address is validated by successfully processing a HANDSHAKE or 1-RTT
// packet.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_fix_address_validation, true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_address_validation, true)
// If true, QuicStream will explicitly specify which RST_STREAM, STOP_SENDING
// frame to send.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_split_up_send_rst, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_split_up_send_rst, false)
// If true, send HTTP/3 GOAWAY frame when sending CONNECTION_CLOSE.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_send_goaway_with_connection_close,
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_send_goaway_with_connection_close,
false)
// If true, ack frequency frame can be sent from server to client.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_can_send_ack_frequency, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_can_send_ack_frequency, false)
// If true, QUIC BBRv2 will support NetworkParams.max_initial_congestion_window
// when bootstrapping cwnd.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_bbr2_support_max_bootstrap_cwnd,
true)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_support_max_bootstrap_cwnd, true)
// If true, QUIC BBR2 will not exit STARTUP on excessive loss, if there was
// enough bandwidth growth in round.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_bbr2_no_exit_startup_on_loss_with_bw_growth,
true)
// Honor the AEAD confidentiality and integrity limits by initiating key update
// (if enabled) and/or closing the connection, as necessary.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_enable_aead_limits, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_aead_limits, false)
// If true, try to process undecryptable packets at the end of
// TlsServerHandshaker::DecryptCallback, if it is callback is run
// asynchronously.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_process_undecryptable_packets_after_async_decrypt_callback,
false)
// When true, QUIC server will send version negotiation packets even if the
// original connection ID was under 64bits in length.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_send_version_negotiation_for_short_connection_ids,
false)
// If true, use one of the 12 QPACK encoder stream error codes and 5 QPACK
// decoder stream error codes and QUIC_INTERNAL_ERROR instead of the two generic
// ones.
QUIC_FLAG(bool,
FLAGS_quic_reloadable_flag_quic_granular_qpack_error_codes,
false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_granular_qpack_error_codes, false)
// When true, the server delays its Initial ACK-only packets the full
// max_ack_delay.
QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_delay_initial_ack, false)
QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_delay_initial_ack, false)
// If true, session tickets will always be enabled in QUIC.
QUIC_FLAG(bool,
FLAGS_quic_restart_flag_quic_session_tickets_always_enabled,
false)
QUIC_FLAG(FLAGS_quic_restart_flag_quic_session_tickets_always_enabled, false)
// If true and B2SL connection option is set, when QUIC BBR2 exits STARTUP due
// to loss, it will set the inflight_hi to the max of bdp and
// max_bytes_delivered_in_round.
QUIC_FLAG(
bool,
FLAGS_quic_reloadable_flag_quic_bbr2_startup_loss_exit_use_max_delivered,
false)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment