@fails-components/webtransport 0.0.1-rc.2 → 0.0.1

package/third_party/quiche/quiche/quic/core/quic_flags_list.h

@@ -6,109 +6,109 @@
 
 #ifdef QUIC_FLAG
 
-QUIC_FLAG(FLAGS_quic_restart_flag_quic_offload_pacing_to_usps2, false)
+QUIC_FLAG(quic_restart_flag_quic_offload_pacing_to_usps2, false)
 // A testonly reloadable flag that will always default to false.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_testonly_default_false, false)
+QUIC_FLAG(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)
+QUIC_FLAG(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)
+QUIC_FLAG(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)
+QUIC_FLAG(quic_restart_flag_quic_testonly_default_true, true)
 // If bytes in flight has dipped below 1.25*MaxBW in the last round, do not exit PROBE_UP due to excess queue buildup.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_no_probe_up_exit_if_no_queue, true)
-// If true, 1) QUIC connections will use a lower minimum for trusted initial rtt, 2) When TRTT is received, QUIC server sessions will mark the initial rtt from CachedNetworkParameters as trusted.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_lower_min_for_trusted_irtt, true)
+QUIC_FLAG(quic_reloadable_flag_quic_bbr2_no_probe_up_exit_if_no_queue, true)
 // If true, QUIC will default enable MTU discovery at server, with a target of 1450 bytes.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_mtu_discovery_at_server, false)
+QUIC_FLAG(quic_reloadable_flag_quic_enable_mtu_discovery_at_server, false)
 // If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so.
-QUIC_FLAG(FLAGS_quic_restart_flag_quic_support_release_time_for_gso, false)
+QUIC_FLAG(quic_restart_flag_quic_support_release_time_for_gso, false)
+// If true, TlsHandshaker::AdvanceHandshake will check if connection is closed after SSL_do_handshake.
+QUIC_FLAG(quic_reloadable_flag_quic_tls_handshaker_check_connection_closed, true)
 // If true, abort async QPACK header decompression in QuicSpdyStream::Reset() and in QuicSpdyStream::OnStreamReset().
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_abort_qpack_on_stream_reset, true)
+QUIC_FLAG(quic_reloadable_flag_quic_abort_qpack_on_stream_reset, true)
 // If true, ack frequency frame can be sent from server to client.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_can_send_ack_frequency, true)
+QUIC_FLAG(quic_reloadable_flag_quic_can_send_ack_frequency, true)
 // 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, true)
+QUIC_FLAG(quic_reloadable_flag_quic_allow_client_enabled_bbr_v2, true)
 // If true, close read side but not write side in QuicSpdyStream::OnStreamReset().
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_on_stream_reset, true)
+QUIC_FLAG(quic_reloadable_flag_quic_fix_on_stream_reset, true)
+// If true, close the connection if a crypto send buffer exceeds its size limit.
+QUIC_FLAG(quic_reloadable_flag_quic_bounded_crypto_send_buffer, false)
 // If true, consider original connection ID as active before handshake completes.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_consider_original_connection_id_as_active_pre_handshake, false)
-// If true, consolidate more logic into SetRetransmissionAlarm to ensure the logic is applied consistently.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_simplify_set_retransmission_alarm, true)
+QUIC_FLAG(quic_reloadable_flag_quic_consider_original_connection_id_as_active_pre_handshake, true)
 // If true, default-enable 5RTO blachole detection.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_enable_5rto_blackhole_detection2, true)
+QUIC_FLAG(quic_reloadable_flag_quic_default_enable_5rto_blackhole_detection2, true)
 // If true, deliver INITIAL packets before other types of packets in QuicBufferedPacketStore.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_deliver_initial_packets_first, true)
+QUIC_FLAG(quic_reloadable_flag_quic_deliver_initial_packets_first, true)
 // If true, disable QUIC version Q043.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q043, false)
+QUIC_FLAG(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)
+QUIC_FLAG(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)
+QUIC_FLAG(quic_reloadable_flag_quic_disable_version_q050, false)
 // If true, disable QUIC version h3 (RFCv1).
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_rfcv1, false)
+QUIC_FLAG(quic_reloadable_flag_quic_disable_version_rfcv1, false)
 // If true, disable QUIC version h3-29.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_draft_29, false)
+QUIC_FLAG(quic_reloadable_flag_quic_disable_version_draft_29, false)
 // If true, disable blackhole detection on server side.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_server_blackhole_detection, false)
+QUIC_FLAG(quic_reloadable_flag_quic_disable_server_blackhole_detection, false)
 // If true, disable resumption when receiving NRES connection option.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_disable_resumption, true)
+QUIC_FLAG(quic_reloadable_flag_quic_enable_disable_resumption, 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)
+QUIC_FLAG(quic_reloadable_flag_quic_discard_initial_packet_with_key_dropped, true)
 // If true, do not bundle ACK while sending PATH_CHALLENGE on alternative path.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_not_bundle_ack_on_alternative_path, true)
+QUIC_FLAG(quic_reloadable_flag_quic_not_bundle_ack_on_alternative_path, true)
 // If true, enable server retransmittable on wire PING.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_server_on_wire_ping, true)
+QUIC_FLAG(quic_reloadable_flag_quic_enable_server_on_wire_ping, true)
 // If true, flush pending frames as well as pending padding bytes on connection migration.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_flush_pending_frames_and_padding_bytes_on_migration, true)
+QUIC_FLAG(quic_reloadable_flag_quic_flush_pending_frames_and_padding_bytes_on_migration, true)
 // If true, ietf connection migration is no longer conditioned on connection option RVCM.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_remove_connection_migration_connection_option_v2, false)
+QUIC_FLAG(quic_reloadable_flag_quic_remove_connection_migration_connection_option_v2, false)
 // If true, include offset in QUIC STREAM_DATA_BLOCKED and DATA_BLOCKED frames.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_include_offset_in_blocked_frames, false)
+QUIC_FLAG(quic_reloadable_flag_quic_include_offset_in_blocked_frames, false)
 // 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)
+QUIC_FLAG(quic_reloadable_flag_quic_add_stream_info_to_idle_close_detail, true)
 // If true, quic server will send ENABLE_CONNECT_PROTOCOL setting and and endpoint will validate required request/response headers and extended CONNECT mechanism and update code counts of valid/invalid headers.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_verify_request_headers_2, true)
+QUIC_FLAG(quic_reloadable_flag_quic_verify_request_headers_2, true)
 // If true, reject or send error response code upon receiving invalid request or response headers. This flag depends on --gfe2_reloadable_flag_quic_verify_request_headers_2.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_act_upon_invalid_header, false)
+QUIC_FLAG(quic_reloadable_flag_quic_act_upon_invalid_header, false)
 // If true, require handshake confirmation for QUIC connections, functionally disabling 0-rtt handshakes.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_require_handshake_confirmation, false)
+QUIC_FLAG(quic_reloadable_flag_quic_require_handshake_confirmation, false)
 // If true, server proactively retires client issued connection ID on reverse path validation failure. 
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_retire_cid_on_reverse_path_validation_failure, true)
+QUIC_FLAG(quic_reloadable_flag_quic_retire_cid_on_reverse_path_validation_failure, true)
 // If true, server sends bandwidth eastimate when network is idle for a while.
-QUIC_FLAG(FLAGS_quic_restart_flag_quic_enable_sending_bandwidth_estimate_when_network_idle, true)
+QUIC_FLAG(quic_restart_flag_quic_enable_sending_bandwidth_estimate_when_network_idle, true)
 // If true, set burst token to 2 in cwnd bootstrapping experiment.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_conservative_bursts, false)
+QUIC_FLAG(quic_reloadable_flag_quic_conservative_bursts, 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)
+QUIC_FLAG(quic_reloadable_flag_quic_donot_reset_ideal_next_packet_send_time, 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)
+QUIC_FLAG(quic_reloadable_flag_quic_default_to_bbr_v2, false)
 // If true, use PING manager to manage the PING alarm.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_ping_manager2, true)
+QUIC_FLAG(quic_reloadable_flag_quic_use_ping_manager2, true)
 // If true, use new connection ID in connection migration.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_connection_migration_use_new_cid_v2, true)
+QUIC_FLAG(quic_reloadable_flag_quic_connection_migration_use_new_cid_v2, true)
 // If true, uses conservative cwnd gain and pacing gain when cwnd gets bootstrapped.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_conservative_cwnd_and_pacing_gains, false)
+QUIC_FLAG(quic_reloadable_flag_quic_conservative_cwnd_and_pacing_gains, false)
 // When the flag is true, exit STARTUP after the same number of loss events as PROBE_UP.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_startup_probe_up_loss_events, true)
+QUIC_FLAG(quic_reloadable_flag_quic_bbr2_startup_probe_up_loss_events, true)
 // When true, defaults to BBR congestion control instead of Cubic.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr, false)
+QUIC_FLAG(quic_reloadable_flag_quic_default_to_bbr, false)
 // When true, prevents QUIC\'s PacingSender from generating bursts when the congestion controller is CWND limited and not pacing limited.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_pacing_sender_bursts, true)
+QUIC_FLAG(quic_reloadable_flag_quic_fix_pacing_sender_bursts, true)
 // 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, true)
+QUIC_FLAG(quic_reloadable_flag_quic_unified_iw_options, true)
 // When true, support draft-ietf-quic-v2-01
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_version_2_draft_01, false)
+QUIC_FLAG(quic_reloadable_flag_quic_enable_version_2_draft_01, false)
 // When true, the B203 connection option causes the Bbr2Sender to ignore inflight_hi during PROBE_UP and increase it when the bytes delivered without loss are higher.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_ignore_inflight_hi_in_probe_up, true)
+QUIC_FLAG(quic_reloadable_flag_quic_bbr2_ignore_inflight_hi_in_probe_up, true)
 // When true, the B205 connection option enables extra acked in STARTUP, and B204 adds new logic to decrease it whenever max bandwidth increases.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_startup_extra_acked, true)
+QUIC_FLAG(quic_reloadable_flag_quic_bbr2_startup_extra_acked, true)
 // When true, the B207 connection option causes BBR2 to exit STARTUP if a persistent queue of 2*BDP has existed for the entire round.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_exit_startup_on_persistent_queue2, true)
+QUIC_FLAG(quic_reloadable_flag_quic_bbr2_exit_startup_on_persistent_queue2, true)
 // When true, the BBQ0 connection option causes QUIC BBR2 to add bytes_acked to probe_up_acked if the connection hasn\'t been app-limited since inflight_hi was utilized.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_add_bytes_acked_after_inflight_hi_limited, true)
+QUIC_FLAG(quic_reloadable_flag_quic_bbr2_add_bytes_acked_after_inflight_hi_limited, true)
 // When true, the BBR4 copt sets the extra_acked window to 20 RTTs and BBR5 sets it to 40 RTTs.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_extra_acked_window, true)
+QUIC_FLAG(quic_reloadable_flag_quic_bbr2_extra_acked_window, true)
 
 #endif
 

package/third_party/quiche/quiche/quic/core/quic_flow_controller_test.cc

@@ -95,13 +95,16 @@ TEST_F(QuicFlowControllerTest, SendingBytes) {
   EXPECT_EQ(send_window_, flow_controller_->SendWindowSize());
 
   // Try to send more bytes, violating flow control.
-  EXPECT_CALL(*connection_,
-              CloseConnection(QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA, _, _));
   EXPECT_QUIC_BUG(
-      flow_controller_->AddBytesSent(send_window_ * 10),
+      {
+        EXPECT_CALL(
+            *connection_,
+            CloseConnection(QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA, _, _));
+        flow_controller_->AddBytesSent(send_window_ * 10);
+        EXPECT_TRUE(flow_controller_->IsBlocked());
+        EXPECT_EQ(0u, flow_controller_->SendWindowSize());
+      },
       absl::StrCat("Trying to send an extra ", send_window_ * 10, " bytes"));
-  EXPECT_TRUE(flow_controller_->IsBlocked());
-  EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 }
 
 TEST_F(QuicFlowControllerTest, ReceivingBytes) {

package/third_party/quiche/quiche/quic/core/quic_framer_test.cc

@@ -10446,11 +10446,14 @@ TEST_P(QuicFramerTest, EncryptEmptyPacket) {
       /*retry_token_length=*/0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
   char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length = 1;
-  EXPECT_QUIC_BUG(encrypted_length = framer_.EncryptPayload(
-                      ENCRYPTION_INITIAL, kPacketNumber, *packet, buffer,
-                      kMaxOutgoingPacketSize),
-                  "packet is shorter than associated data length");
-  EXPECT_EQ(0u, encrypted_length);
+  EXPECT_QUIC_BUG(
+      {
+        encrypted_length =
+            framer_.EncryptPayload(ENCRYPTION_INITIAL, kPacketNumber, *packet,
+                                   buffer, kMaxOutgoingPacketSize);
+        EXPECT_EQ(0u, encrypted_length);
+      },
+      "packet is shorter than associated data length");
 }
 
 TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) {

package/third_party/quiche/quiche/quic/core/quic_idle_network_detector.cc

@@ -71,6 +71,7 @@ void QuicIdleNetworkDetector::SetTimeouts(
     QuicTime::Delta handshake_timeout, QuicTime::Delta idle_network_timeout) {
   handshake_timeout_ = handshake_timeout;
   idle_network_timeout_ = idle_network_timeout;
+  bandwidth_update_timeout_ = QuicTime::Delta::Infinite();
 
   if (GetQuicRestartFlag(
           quic_enable_sending_bandwidth_estimate_when_network_idle) &&

package/third_party/quiche/quiche/quic/core/quic_idle_network_detector_test.cc

@@ -247,6 +247,35 @@ TEST_F(QuicIdleNetworkDetectorTest, NoAlarmAfterStopped) {
   EXPECT_FALSE(alarm_->IsSet());
 }
 
+TEST_F(QuicIdleNetworkDetectorTest,
+       ResetBandwidthTimeoutWhenHandshakeTimeoutIsSet) {
+  if (!GetQuicRestartFlag(
+          quic_enable_sending_bandwidth_estimate_when_network_idle)) {
+    return;
+  }
+  detector_->SetTimeouts(
+      /*handshake_timeout=*/QuicTime::Delta::Infinite(),
+      /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(20));
+  // The deadline is set based on the bandwidth timeout.
+  EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(10),
+            alarm_->deadline());
+
+  detector_->SetTimeouts(
+      /*handshake_timeout=*/QuicTime::Delta::FromSeconds(15),
+      /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(20));
+  // Bandwidth timeout is reset and the deadline is set based on the handshake
+  // timeout.
+  EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(15),
+            alarm_->deadline());
+
+  detector_->SetTimeouts(
+      /*handshake_timeout=*/QuicTime::Delta::Infinite(),
+      /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(20));
+  // The deadline is set based on the bandwidth timeout.
+  EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(10),
+            alarm_->deadline());
+}
+
 }  // namespace
 
 }  // namespace test

package/third_party/quiche/quiche/quic/core/quic_packet_creator.cc

@@ -1875,10 +1875,6 @@ void QuicPacketCreator::MaybeAddPadding() {
     return;
   }
 
-  if (packet_.transmission_type == PROBING_RETRANSMISSION) {
-    needs_full_padding_ = true;
-  }
-
   if (packet_.fate == COALESCE || packet_.fate == LEGACY_VERSION_ENCAPSULATE) {
     // Do not add full padding if the packet is going to be coalesced or
     // encapsulated.
@@ -2076,7 +2072,7 @@ size_t QuicPacketCreator::MinPlaintextPacketSize(
   // 1.3 is used, unittests still use NullEncrypter/NullDecrypter (and other
   // test crypters) which also only use 12 byte tags.
   //
-  // TODO(nharper): Set this based on the handshake protocol in use.
+  // TODO(b/234061734): Set this based on the handshake protocol in use.
   return 7;
 }
 

package/third_party/quiche/quiche/quic/core/quic_packet_creator_test.cc

@@ -1549,11 +1549,13 @@ TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) {
   }
 
   creator_.set_encryption_level(ENCRYPTION_INITIAL);
-  EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
   QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
                                /*fin=*/false, 0u, absl::string_view());
   EXPECT_QUIC_BUG(
-      creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
+      {
+        EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
+        creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION);
+      },
       "Cannot send stream data with level: ENCRYPTION_INITIAL");
 }
 
@@ -1564,11 +1566,13 @@ TEST_P(QuicPacketCreatorTest, SendStreamDataWithEncryptionHandshake) {
   }
 
   creator_.set_encryption_level(ENCRYPTION_HANDSHAKE);
-  EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
   QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
                                /*fin=*/false, 0u, absl::string_view());
   EXPECT_QUIC_BUG(
-      creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
+      {
+        EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
+        creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION);
+      },
       "Cannot send stream data with level: ENCRYPTION_HANDSHAKE");
 }
 
@@ -1935,7 +1939,7 @@ TEST_P(QuicPacketCreatorTest, PacketTransmissionType) {
   EXPECT_TRUE(creator_.AddFrame(stream_frame, PTO_RETRANSMISSION));
   ASSERT_EQ(serialized_packet_, nullptr);
 
-  EXPECT_TRUE(creator_.AddFrame(padding_frame, PROBING_RETRANSMISSION));
+  EXPECT_TRUE(creator_.AddFrame(padding_frame, LOSS_RETRANSMISSION));
   creator_.FlushCurrentPacket();
   ASSERT_TRUE(serialized_packet_->encrypted_buffer);
 
@@ -2563,12 +2567,15 @@ TEST_F(QuicPacketCreatorMultiplePacketsTest,
   delegate_.SetCanWriteAnything();
   const std::string data(10000, '?');
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).Times(0);
-  EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
-  EXPECT_QUIC_BUG(creator_.ConsumeDataFastPath(
-                      QuicUtils::GetFirstBidirectionalStreamId(
-                          framer_.transport_version(), Perspective::IS_CLIENT),
-                      data),
-                  "");
+  EXPECT_QUIC_BUG(
+      {
+        EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
+        creator_.ConsumeDataFastPath(
+            QuicUtils::GetFirstBidirectionalStreamId(
+                framer_.transport_version(), Perspective::IS_CLIENT),
+            data);
+      },
+      "");
 }
 
 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddControlFrame_OnlyAckWritable) {

package/third_party/quiche/quiche/quic/core/quic_sent_packet_manager.cc

@@ -47,7 +47,6 @@ static const float kPtoMultiplierWithoutRttSamples = 3;
 // the frames directly (as opposed to resulting in a loss notification).
 inline bool ShouldForceRetransmission(TransmissionType transmission_type) {
   return transmission_type == HANDSHAKE_RETRANSMISSION ||
-         transmission_type == PROBING_RETRANSMISSION ||
          transmission_type == PTO_RETRANSMISSION;
 }
 
@@ -286,24 +285,18 @@ void QuicSentPacketManager::AdjustNetworkParameters(
   const QuicBandwidth& bandwidth = params.bandwidth;
   const QuicTime::Delta& rtt = params.rtt;
 
-  if (use_lower_min_irtt()) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_lower_min_for_trusted_irtt, 2, 2);
-    if (!rtt.IsZero()) {
-      if (params.is_rtt_trusted) {
-        // Always set initial rtt if it's trusted.
-        SetInitialRtt(rtt, /*trusted=*/true);
-      } else if (rtt_stats_.initial_rtt() ==
-                 QuicTime::Delta::FromMilliseconds(kInitialRttMs)) {
-        // Only set initial rtt if we are using the default. This avoids
-        // overwriting a trusted initial rtt by an untrusted one.
-        SetInitialRtt(rtt, /*trusted=*/false);
-      }
-    }
-  } else {
-    if (!rtt.IsZero()) {
+  if (!rtt.IsZero()) {
+    if (params.is_rtt_trusted) {
+      // Always set initial rtt if it's trusted.
+      SetInitialRtt(rtt, /*trusted=*/true);
+    } else if (rtt_stats_.initial_rtt() ==
+               QuicTime::Delta::FromMilliseconds(kInitialRttMs)) {
+      // Only set initial rtt if we are using the default. This avoids
+      // overwriting a trusted initial rtt by an untrusted one.
       SetInitialRtt(rtt, /*trusted=*/false);
     }
   }
+
   const QuicByteCount old_cwnd = send_algorithm_->GetCongestionWindow();
   if (GetQuicReloadableFlag(quic_conservative_bursts) && using_pacing_ &&
       !bandwidth.IsZero()) {
@@ -509,9 +502,6 @@ void QuicSentPacketManager::MarkForRetransmission(
       << "packet number " << packet_number
       << " transmission_type: " << transmission_type << " transmission_info "
       << transmission_info->DebugString();
-  // Handshake packets should never be sent as probing retransmissions.
-  QUICHE_DCHECK(!transmission_info->has_crypto_handshake ||
-                transmission_type != PROBING_RETRANSMISSION);
   if (ShouldForceRetransmission(transmission_type)) {
     if (!unacked_packets_.RetransmitFrames(
             QuicFrames(transmission_info->retransmittable_frames),
@@ -996,15 +986,6 @@ const QuicTime QuicSentPacketManager::GetRetransmissionTime() const {
     // Do not set the timer if there is any credit left.
     return QuicTime::Zero();
   }
-  PacketNumberSpace packet_number_space;
-  if (!simplify_set_retransmission_alarm_ &&
-      supports_multiple_packet_number_spaces() &&
-      unacked_packets_.perspective() == Perspective::IS_SERVER &&
-      !GetEarliestPacketSentTimeForPto(&packet_number_space).IsInitialized()) {
-    // Do not set the timer on the server side if the only in flight packets are
-    // half RTT data.
-    return QuicTime::Zero();
-  }
   switch (GetRetransmissionMode()) {
     case HANDSHAKE_MODE:
       return unacked_packets_.GetLastCryptoPacketSentTime() +

package/third_party/quiche/quiche/quic/core/quic_sent_packet_manager.h

@@ -464,12 +464,6 @@ class QUIC_EXPORT_PRIVATE QuicSentPacketManager {
   // kMinUntrustedInitialRoundTripTimeUs if not |trusted|.
   void SetInitialRtt(QuicTime::Delta rtt, bool trusted);
 
-  bool use_lower_min_irtt() const { return use_lower_min_irtt_; }
-
-  bool simplify_set_retransmission_alarm() const {
-    return simplify_set_retransmission_alarm_;
-  }
-
  private:
   friend class test::QuicConnectionPeer;
   friend class test::QuicSentPacketManagerPeer;
@@ -674,13 +668,6 @@ class QUIC_EXPORT_PRIVATE QuicSentPacketManager {
 
   // Whether to ignore the ack_delay in received ACKs.
   bool ignore_ack_delay_;
-
-  // Latched value of --quic_use_lower_min_for_trusted_irtt.
-  bool use_lower_min_irtt_ =
-      GetQuicReloadableFlag(quic_use_lower_min_for_trusted_irtt);
-
-  const bool simplify_set_retransmission_alarm_ =
-      GetQuicReloadableFlag(quic_simplify_set_retransmission_alarm);
 };
 
 }  // namespace quic

package/third_party/quiche/quiche/quic/core/quic_sent_packet_manager_test.cc

@@ -208,8 +208,7 @@ class QuicSentPacketManagerTest : public QuicTest {
                                TransmissionType transmission_type) {
     bool is_lost = false;
     if (transmission_type == HANDSHAKE_RETRANSMISSION ||
-        transmission_type == PTO_RETRANSMISSION ||
-        transmission_type == PROBING_RETRANSMISSION) {
+        transmission_type == PTO_RETRANSMISSION) {
       EXPECT_CALL(notifier_, RetransmitFrames(_, _))
           .WillOnce(WithArgs<1>(
               Invoke([this, new_packet_number](TransmissionType type) {
@@ -2699,53 +2698,6 @@ TEST_F(QuicSentPacketManagerTest, ClearLastInflightPacketsSentTime) {
   EXPECT_EQ(packet2_sent_time + pto_delay, manager_.GetRetransmissionTime());
 }
 
-// Regression test for b/157895910.
-TEST_F(QuicSentPacketManagerTest, EarliestSentTimeNotInitializedWhenPtoFires) {
-  if (GetQuicReloadableFlag(quic_simplify_set_retransmission_alarm)) {
-    return;
-  }
-  manager_.EnableMultiplePacketNumberSpacesSupport();
-  EXPECT_CALL(*send_algorithm_, PacingRate(_))
-      .WillRepeatedly(Return(QuicBandwidth::Zero()));
-  EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
-      .WillRepeatedly(Return(10 * kDefaultTCPMSS));
-
-  // Send INITIAL 1.
-  SendDataPacket(1, ENCRYPTION_INITIAL);
-
-  // Send HANDSHAKE packets.
-  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
-  SendDataPacket(2, ENCRYPTION_HANDSHAKE);
-  SendDataPacket(3, ENCRYPTION_HANDSHAKE);
-  SendDataPacket(4, ENCRYPTION_HANDSHAKE);
-
-  // Send half RTT packet.
-  SendDataPacket(5, ENCRYPTION_FORWARD_SECURE);
-
-  // Received ACK for INITIAL packet 1.
-  ExpectAck(1);
-  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(90));
-  manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
-                           clock_.Now());
-  manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
-  EXPECT_EQ(PACKETS_NEWLY_ACKED,
-            manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
-                                   ENCRYPTION_INITIAL));
-
-  // Received ACK for HANDSHAKE packets.
-  uint64_t acked[] = {2, 3, 4};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
-  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(90));
-  manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
-                           clock_.Now());
-  manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(5));
-  EXPECT_EQ(PACKETS_NEWLY_ACKED,
-            manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(4),
-                                   ENCRYPTION_HANDSHAKE));
-  // Verify PTO will not be armed.
-  EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
-}
-
 TEST_F(QuicSentPacketManagerTest, MaybeRetransmitInitialData) {
   manager_.EnableMultiplePacketNumberSpacesSupport();
   EXPECT_CALL(*send_algorithm_, PacingRate(_))

package/third_party/quiche/quiche/quic/core/quic_session.cc

@@ -692,14 +692,6 @@ void QuicSession::OnCanWrite() {
   }
 }
 
-bool QuicSession::SendProbingData() {
-  if (connection()->sent_packet_manager().MaybeRetransmitOldestPacket(
-          PROBING_RETRANSMISSION)) {
-    return true;
-  }
-  return false;
-}
-
 bool QuicSession::WillingAndAbleToWrite() const {
   // Schedule a write when:
   // 1) control frame manager has pending or new control frames, or

package/third_party/quiche/quiche/quic/core/quic_session.h

@@ -138,7 +138,6 @@ class QUIC_EXPORT_PRIVATE QuicSession
                         const QuicSocketAddress& peer_address,
                         bool is_connectivity_probe) override;
   void OnCanWrite() override;
-  bool SendProbingData() override;
   void OnCongestionWindowChange(QuicTime /*now*/) override {}
   void OnConnectionMigration(AddressChangeType /*type*/) override {}
   // Adds a connection level WINDOW_UPDATE frame.

package/third_party/quiche/quiche/quic/core/quic_stream.cc

@@ -1136,7 +1136,7 @@ void QuicStream::OnStreamFrameLost(QuicStreamOffset offset,
 bool QuicStream::RetransmitStreamData(QuicStreamOffset offset,
                                       QuicByteCount data_length, bool fin,
                                       TransmissionType type) {
-  QUICHE_DCHECK(type == PTO_RETRANSMISSION || type == PROBING_RETRANSMISSION);
+  QUICHE_DCHECK(type == PTO_RETRANSMISSION);
   if (HasDeadlinePassed()) {
     OnDeadlinePassed();
     return true;

package/third_party/quiche/quiche/quic/core/quic_stream_sequencer.cc

@@ -292,6 +292,11 @@ QuicStreamOffset QuicStreamSequencer::NumBytesConsumed() const {
   return buffered_frames_.BytesConsumed();
 }
 
+bool QuicStreamSequencer::IsAllDataAvailable() const {
+  QUICHE_DCHECK_LE(NumBytesConsumed() + NumBytesBuffered(), close_offset_);
+  return NumBytesConsumed() + NumBytesBuffered() >= close_offset_;
+}
+
 const std::string QuicStreamSequencer::DebugString() const {
   // clang-format off
   return absl::StrCat("QuicStreamSequencer:",

package/third_party/quiche/quiche/quic/core/quic_stream_sequencer.h

@@ -139,6 +139,10 @@ class QUIC_EXPORT_PRIVATE QuicStreamSequencer {
   // Number of bytes has been consumed.
   QuicStreamOffset NumBytesConsumed() const;
 
+  // Returns true if all of the data within the stream up until the FIN is
+  // available.
+  bool IsAllDataAvailable() const;
+
   QuicStreamOffset close_offset() const { return close_offset_; }
 
   int num_frames_received() const { return num_frames_received_; }

package/third_party/quiche/quiche/quic/core/quic_stream_sequencer_test.cc

@@ -223,8 +223,10 @@ TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) {
     ConsumeData(3);
   }));
   EXPECT_FALSE(sequencer_->IsClosed());
+  EXPECT_FALSE(sequencer_->IsAllDataAvailable());
   OnFinFrame(3, "def");
   EXPECT_TRUE(sequencer_->IsClosed());
+  EXPECT_TRUE(sequencer_->IsAllDataAvailable());
 }
 
 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
@@ -239,6 +241,7 @@ TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
     ConsumeData(3);
   }));
   EXPECT_FALSE(sequencer_->IsClosed());
+  EXPECT_TRUE(sequencer_->IsAllDataAvailable());
   sequencer_->SetUnblocked();
   EXPECT_TRUE(sequencer_->IsClosed());
   EXPECT_EQ(0u, NumBufferedBytes());
@@ -260,6 +263,7 @@ TEST_F(QuicStreamSequencerTest, EmptyFinFrame) {
   OnFinFrame(0, "");
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
+  EXPECT_TRUE(sequencer_->IsAllDataAvailable());
 }
 
 TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) {
@@ -560,11 +564,14 @@ TEST_F(QuicStreamSequencerTest, MarkConsumedError) {
 
   // Now, attempt to mark consumed more data than was readable and expect the
   // stream to be closed.
-  EXPECT_CALL(stream_, ResetWithError(QuicResetStreamError::FromInternal(
-                           QUIC_ERROR_PROCESSING_STREAM)));
-  EXPECT_QUIC_BUG(sequencer_->MarkConsumed(4),
-                  "Invalid argument to MarkConsumed."
-                  " expect to consume: 4, but not enough bytes available.");
+  EXPECT_QUIC_BUG(
+      {
+        EXPECT_CALL(stream_, ResetWithError(QuicResetStreamError::FromInternal(
+                                 QUIC_ERROR_PROCESSING_STREAM)));
+        sequencer_->MarkConsumed(4);
+      },
+      "Invalid argument to MarkConsumed."
+      " expect to consume: 4, but not enough bytes available.");
 }
 
 TEST_F(QuicStreamSequencerTest, MarkConsumedWithMissingPacket) {