| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // This file intentionally does not have header guards, it's included |
| // inside a macro to generate values. The following line silences a |
| // presubmit warning that would otherwise be triggered by this: |
| // no-include-guard-because-multiply-included |
| // NOLINT(build/header_guard) |
| |
| // 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(FLAGS_quic_reloadable_flag_quic_require_handshake_confirmation, false) |
| |
| // When true, defaults to BBR congestion control instead of Cubic. |
| 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(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(FLAGS_quic_reloadable_flag_quic_unified_iw_options, false) |
| |
| // If true, QUIC offload pacing when using USPS as egress method. |
| 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( |
| 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(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( |
| 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(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(FLAGS_quic_reloadable_flag_quic_conservative_bursts, false) |
| |
| // If true, uses conservative cwnd gain and pacing gain. |
| 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(FLAGS_quic_reloadable_flag_quic_allow_client_enabled_bbr_v2, false) |
| |
| // If true, disable QUIC version Q043. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q043, false) |
| |
| // If true, disable QUIC version Q046. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q046, false) |
| |
| // If true, disable QUIC version Q050. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q050, false) |
| |
| // A testonly reloadable flag that will always default to false. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_testonly_default_false, false) |
| |
| // A testonly reloadable flag that will always default to true. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_testonly_default_true, true) |
| |
| // A testonly restart flag that will always default to false. |
| QUIC_FLAG(FLAGS_quic_restart_flag_quic_testonly_default_false, false) |
| |
| // A testonly restart flag that will always default to 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(FLAGS_quic_reloadable_flag_quic_ack_delay_alarm_granularity, false) |
| |
| // If true, disable QUIC version h3-27. |
| 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(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(FLAGS_quic_reloadable_flag_quic_bbr2_fewer_startup_round_trips, false) |
| |
| // If true, support for IETF QUIC 0-rtt is enabled. |
| 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(FLAGS_quic_reloadable_flag_quic_default_on_pto, false) |
| |
| // If true, disable QUIC version h3-T050. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_t050, true) |
| |
| // If true, default-enable 5RTO blachole detection. |
| QUIC_FLAG( |
| FLAGS_quic_reloadable_flag_quic_default_enable_5rto_blackhole_detection2, |
| true) |
| |
| // If true, disable QUIC version h3-29. |
| 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(FLAGS_quic_reloadable_flag_quic_record_received_min_ack_delay, true) |
| |
| // If true, disable blackhole detection on server side. |
| 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(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(FLAGS_quic_reloadable_flag_quic_start_peer_migration_earlier, false) |
| |
| // If true, QuicStream::kDefaultUrgency is 3, otherwise 1. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_http3_new_default_urgency_value, true) |
| |
| // If true, send PATH_RESPONSE upon receiving PATH_CHALLENGE regardless |
| // of perspective. |
| 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(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(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( |
| 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(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(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(FLAGS_quic_reloadable_flag_quic_clean_up_spdy_session_destructor, |
| true) |
| |
| // If true, discard INITIAL packet if the key has been dropped. |
| QUIC_FLAG( |
| FLAGS_quic_reloadable_flag_quic_discard_initial_packet_with_key_dropped, |
| true) |
| |
| // If true, disable QUIC version h3-T051. |
| 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(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( |
| 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(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(FLAGS_quic_reloadable_flag_quic_fix_arm_pto_for_application_data, |
| true) |
| |
| // If true, fix a potential out of order sending caused by handshake gets |
| // confirmed while the coalescer is not empty. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_out_of_order_sending2, true) |
| |
| // If true, remove processed undecryptable packets. |
| 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( |
| 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(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(FLAGS_quic_reloadable_flag_quic_reject_spdy_settings, true) |
| |
| // If true, for IETF QUIC, uses 2 * RTTVAR when calculating PTO delay. |
| 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(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(FLAGS_quic_reloadable_flag_quic_fix_missing_initial_keys2, true) |
| |
| // If true, check whether framer has the right key before writing data. |
| 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(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(FLAGS_quic_reloadable_flag_quic_reject_spdy_frames, true) |
| |
| // 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(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(FLAGS_quic_reloadable_flag_quic_let_connection_handle_pings, true) |
| |
| // If true, use http2::HuffmanEncodeFast() instead of HuffmanEncode() and |
| // eliminate one string copy for QPACK encoding used in IETF QUIC. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_fast_huffman_encoder, true) |
| |
| // When true, QUIC+TLS versions will support key updates. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_key_update_supported, true) |
| |
| // If true, address is validated by successfully processing a HANDSHAKE or 1-RTT |
| // packet. |
| 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(FLAGS_quic_reloadable_flag_quic_split_up_send_rst, false) |
| |
| // If true, send HTTP/3 GOAWAY frame when sending 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(FLAGS_quic_reloadable_flag_quic_can_send_ack_frequency, true) |
| |
| // If true, QUIC BBRv2 will support NetworkParams.max_initial_congestion_window |
| // when bootstrapping cwnd. |
| 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( |
| 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(FLAGS_quic_reloadable_flag_quic_enable_aead_limits, true) |
| |
| // If true, try to process undecryptable packets at the end of |
| // TlsServerHandshaker::DecryptCallback, if it is callback is run |
| // asynchronously. |
| QUIC_FLAG( |
| 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( |
| 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(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(FLAGS_quic_reloadable_flag_quic_delay_initial_ack, false) |
| |
| // If true, session tickets will always be enabled in QUIC. |
| 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( |
| FLAGS_quic_reloadable_flag_quic_bbr2_startup_loss_exit_use_max_delivered, |
| false) |
| |
| // If true, fix QuicSession::WillingAndAbleToWrite to check write keys when |
| // using CRYPTO frames. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_willing_and_able_to_write2, true) |
| |
| // If true, do not send control frames before encryption is established. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_encrypted_control_frames, false) |
| |
| // If true, use WriteOrBufferDataAtLevel to send crypto data. Existing |
| // WriteOrBufferData is used to send application data. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_write_or_buffer_data_at_level, |
| false) |
| |
| // When true, use quic::CertificateView to extract X.509 subjects from |
| // certificates. |
| QUIC_FLAG( |
| FLAGS_quic_reloadable_flag_quic_extract_x509_subject_using_certificate_view, |
| false) |
| |
| // If true, use ScopedEncryptionLevelContext when sending data. |
| QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_encryption_level_context, false) |
