@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

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

@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/base/optimization.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/chlo_extractor.h"
@@ -147,6 +148,7 @@ class PacketCollector : public QuicPacketCreator::DelegateInterface,
 class StatelessConnectionTerminator {
  public:
   StatelessConnectionTerminator(QuicConnectionId server_connection_id,
+                                QuicConnectionId original_server_connection_id,
                                 const ParsedQuicVersion version,
                                 QuicConnectionHelperInterface* helper,
                                 QuicTimeWaitListManager* time_wait_list_manager)
@@ -158,7 +160,8 @@ class StatelessConnectionTerminator {
         creator_(server_connection_id, &framer_, &collector_),
         time_wait_list_manager_(time_wait_list_manager) {
     framer_.set_data_producer(&collector_);
-    framer_.SetInitialObfuscators(server_connection_id);
+    // Always set encrypter with original_server_connection_id.
+    framer_.SetInitialObfuscators(original_server_connection_id);
   }
 
   ~StatelessConnectionTerminator() {
@@ -518,7 +521,7 @@ constexpr bool IsSourceUdpPortBlocked(uint16_t port) {
   constexpr size_t num_blocked_ports = ABSL_ARRAYSIZE(blocked_ports);
   constexpr uint16_t highest_blocked_port =
       blocked_ports[num_blocked_ports - 1];
-  if (QUICHE_PREDICT_TRUE(port > highest_blocked_port)) {
+  if (ABSL_PREDICT_TRUE(port > highest_blocked_port)) {
     // Early-return to skip comparisons for the majority of traffic.
     return false;
   }
@@ -901,8 +904,9 @@ void QuicDispatcher::CleanUpSession(QuicConnectionId server_connection_id,
       // This serializes a connection close termination packet and adds the
       // connection to the time wait list.
       StatelessConnectionTerminator terminator(
-          server_connection_id, connection->version(), helper_.get(),
-          time_wait_list_manager_.get());
+          server_connection_id,
+          connection->GetOriginalDestinationConnectionId(),
+          connection->version(), helper_.get(), time_wait_list_manager_.get());
       terminator.CloseConnection(
           QUIC_HANDSHAKE_FAILED,
           "Connection is closed by server before handshake confirmed",
@@ -1137,9 +1141,9 @@ void QuicDispatcher::StatelesslyTerminateConnection(
         << version << ", error_code:" << error_code
         << ", error_details:" << error_details;
 
-    StatelessConnectionTerminator terminator(server_connection_id, version,
-                                             helper_.get(),
-                                             time_wait_list_manager_.get());
+    StatelessConnectionTerminator terminator(
+        server_connection_id, server_connection_id, version, helper_.get(),
+        time_wait_list_manager_.get());
     // This also adds the connection to time wait list.
     terminator.CloseConnection(
         error_code, error_details, format != GOOGLE_QUIC_PACKET,
@@ -1313,7 +1317,7 @@ void QuicDispatcher::ProcessChlo(ParsedClientHello parsed_chlo,
   std::unique_ptr<QuicSession> session = CreateQuicSession(
       packet_info->destination_connection_id, packet_info->self_address,
       packet_info->peer_address, alpn, packet_info->version, parsed_chlo);
-  if (QUIC_PREDICT_FALSE(session == nullptr)) {
+  if (ABSL_PREDICT_FALSE(session == nullptr)) {
     QUIC_BUG(quic_bug_10287_8)
         << "CreateQuicSession returned nullptr for "
         << packet_info->destination_connection_id << " from "
@@ -1321,7 +1325,9 @@ void QuicDispatcher::ProcessChlo(ParsedClientHello parsed_chlo,
         << " ALPN \"" << alpn << "\" version " << packet_info->version;
     return;
   }
-  if (original_connection_id != packet_info->destination_connection_id) {
+  const bool replaced_connection_id =
+      original_connection_id != packet_info->destination_connection_id;
+  if (replaced_connection_id) {
     session->connection()->SetOriginalDestinationConnectionId(
         original_connection_id);
   }
@@ -1342,8 +1348,11 @@ void QuicDispatcher::ProcessChlo(ParsedClientHello parsed_chlo,
   }
   session_ptr = insertion_result.first->second.get();
   std::list<BufferedPacket> packets =
-      buffered_packets_.DeliverPackets(packet_info->destination_connection_id)
-          .buffered_packets;
+      buffered_packets_.DeliverPackets(original_connection_id).buffered_packets;
+  if (replaced_connection_id && !packets.empty()) {
+    QUIC_CODE_COUNT(
+        quic_delivered_buffered_packets_to_connection_with_replaced_id);
+  }
   // Process CHLO at first.
   session_ptr->ProcessUdpPacket(packet_info->self_address,
                                 packet_info->peer_address, packet_info->packet);

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

@@ -490,7 +490,8 @@ class QuicDispatcherTestBase : public QuicTestWithParam<ParsedQuicVersion> {
     ProcessFirstFlight(version, client_address, connection_id);
   }
 
-  void TestTlsMultiPacketClientHello(bool add_reordering);
+  void TestTlsMultiPacketClientHello(bool add_reordering,
+                                     bool long_connection_id);
 
   void TestVersionNegotiationForUnknownVersionInvalidShortInitialConnectionId(
       const QuicConnectionId& server_connection_id,
@@ -560,14 +561,23 @@ TEST_P(QuicDispatcherTestAllVersions, TlsClientHelloCreatesSession) {
 }
 
 void QuicDispatcherTestBase::TestTlsMultiPacketClientHello(
-    bool add_reordering) {
+    bool add_reordering, bool long_connection_id) {
   if (!version_.UsesTls()) {
     return;
   }
   SetAddressToken("857293462398");
 
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
-  QuicConnectionId server_connection_id = TestConnectionId();
+  QuicConnectionId original_connection_id, new_connection_id;
+  if (long_connection_id) {
+    original_connection_id = QuicConnectionId(
+        {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09});
+    new_connection_id =
+        QuicConnectionId({0x6c, 0x6b, 0x4b, 0xad, 0x8d, 0x00, 0x24, 0xd8});
+  } else {
+    original_connection_id = TestConnectionId();
+    new_connection_id = original_connection_id;
+  }
   QuicConfig client_config = DefaultQuicConfig();
   // Add a 2000-byte custom parameter to increase the length of the CHLO.
   constexpr auto kCustomParameterId =
@@ -576,7 +586,7 @@ void QuicDispatcherTestBase::TestTlsMultiPacketClientHello(
   client_config.custom_transport_parameters_to_send()[kCustomParameterId] =
       kCustomParameterValue;
   std::vector<std::unique_ptr<QuicReceivedPacket>> packets =
-      GetFirstFlightOfPackets(version_, client_config, server_connection_id,
+      GetFirstFlightOfPackets(version_, client_config, original_connection_id,
                               EmptyQuicConnectionId(),
                               TestClientCryptoConfig());
   ASSERT_EQ(packets.size(), 2u);
@@ -585,11 +595,12 @@ void QuicDispatcherTestBase::TestTlsMultiPacketClientHello(
   }
 
   // Processing the first packet should not create a new session.
-  EXPECT_CALL(*dispatcher_,
-              ShouldCreateOrBufferPacketForConnection(
-                  ReceivedPacketInfoConnectionIdEquals(server_connection_id)));
+  EXPECT_CALL(
+      *dispatcher_,
+      ShouldCreateOrBufferPacketForConnection(
+          ReceivedPacketInfoConnectionIdEquals(original_connection_id)));
   ProcessReceivedPacket(std::move(packets[0]), client_address, version_,
-                        server_connection_id);
+                        original_connection_id);
 
   EXPECT_EQ(dispatcher_->NumSessions(), 0u)
       << "No session should be created before the rest of the CHLO arrives.";
@@ -597,10 +608,10 @@ void QuicDispatcherTestBase::TestTlsMultiPacketClientHello(
   // Processing the second packet should create the new session.
   EXPECT_CALL(
       *dispatcher_,
-      CreateQuicSession(server_connection_id, _, client_address,
+      CreateQuicSession(new_connection_id, _, client_address,
                         Eq(ExpectedAlpn()), _, Eq(ParsedClientHelloForTest())))
       .WillOnce(Return(ByMove(CreateSession(
-          dispatcher_.get(), config_, server_connection_id, client_address,
+          dispatcher_.get(), config_, new_connection_id, client_address,
           &mock_helper_, &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
@@ -608,16 +619,29 @@ void QuicDispatcherTestBase::TestTlsMultiPacketClientHello(
       .Times(2);
 
   ProcessReceivedPacket(std::move(packets[1]), client_address, version_,
-                        server_connection_id);
+                        original_connection_id);
   EXPECT_EQ(dispatcher_->NumSessions(), 1u);
 }
 
 TEST_P(QuicDispatcherTestAllVersions, TlsMultiPacketClientHello) {
-  TestTlsMultiPacketClientHello(/*add_reordering=*/false);
+  TestTlsMultiPacketClientHello(/*add_reordering=*/false,
+                                /*long_connection_id=*/false);
 }
 
 TEST_P(QuicDispatcherTestAllVersions, TlsMultiPacketClientHelloWithReordering) {
-  TestTlsMultiPacketClientHello(/*add_reordering=*/true);
+  TestTlsMultiPacketClientHello(/*add_reordering=*/true,
+                                /*long_connection_id=*/false);
+}
+
+TEST_P(QuicDispatcherTestAllVersions, TlsMultiPacketClientHelloWithLongId) {
+  TestTlsMultiPacketClientHello(/*add_reordering=*/false,
+                                /*long_connection_id=*/true);
+}
+
+TEST_P(QuicDispatcherTestAllVersions,
+       TlsMultiPacketClientHelloWithReorderingAndLongId) {
+  TestTlsMultiPacketClientHello(/*add_reordering=*/true,
+                                /*long_connection_id=*/true);
 }
 
 TEST_P(QuicDispatcherTestAllVersions, LegacyVersionEncapsulation) {

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

@@ -19,8 +19,6 @@ QUIC_FLAG(FLAGS_quic_restart_flag_quic_testonly_default_true, true)
 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)
-// If true, QUIC connection will be closed if it fails to serialize a coalesced packet.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_close_connection_if_fail_to_serialzie_coalesced_packet2, 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)
 // If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so.
@@ -33,6 +31,8 @@ QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_can_send_ack_frequency, true)
 QUIC_FLAG(FLAGS_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)
+// 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)
 // If true, default-enable 5RTO blachole detection.
@@ -52,19 +52,19 @@ QUIC_FLAG(FLAGS_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)
 // If true, disable resumption when receiving NRES connection option.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_disable_resumption, false)
+QUIC_FLAG(FLAGS_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)
 // 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)
 // If true, enable server retransmittable on wire PING.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_server_on_wire_ping, true)
-// If true, flush creator after coalesce packet of higher space.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_flush_after_coalesce_higher_space_packets, 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)
 // 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)
+// 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)
 // 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, 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.
@@ -77,18 +77,14 @@ QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_require_handshake_confirmation, false)
 QUIC_FLAG(FLAGS_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)
-// If true, servers drop received packets with changed server address.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_drop_packets_with_changed_server_address, true)
 // If true, set burst token to 2 in cwnd bootstrapping experiment.
 QUIC_FLAG(FLAGS_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)
-// If true, update ACK timeout based on packet receipt time rather than now.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_update_ack_timeout_on_receipt_time, true)
 // 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)
 // If true, use PING manager to manage the PING alarm.
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_ping_manager, true)
+QUIC_FLAG(FLAGS_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)
 // If true, uses conservative cwnd gain and pacing gain when cwnd gets bootstrapped.

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

@@ -232,10 +232,10 @@ void QuicFlowController::UpdateReceiveWindowOffsetAndSendWindowUpdate(
   SendWindowUpdate();
 }
 
-bool QuicFlowController::ShouldSendBlocked() {
+void QuicFlowController::MaybeSendBlocked() {
   if (SendWindowSize() != 0 ||
       last_blocked_send_window_offset_ >= send_window_offset_) {
-    return false;
+    return;
   }
   QUIC_DLOG(INFO) << ENDPOINT << LogLabel() << " is flow control blocked. "
                   << "Send window: " << SendWindowSize()
@@ -247,7 +247,7 @@ bool QuicFlowController::ShouldSendBlocked() {
   // Keep track of when we last sent a BLOCKED frame so that we only send one
   // at a given send offset.
   last_blocked_send_window_offset_ = send_window_offset_;
-  return true;
+  session_->SendBlocked(id_, last_blocked_send_window_offset_);
 }
 
 bool QuicFlowController::UpdateSendWindowOffset(

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

@@ -78,8 +78,8 @@ class QUIC_EXPORT_PRIVATE QuicFlowController
 
   QuicByteCount receive_window_size() const { return receive_window_size_; }
 
-  // Returns whether a BLOCKED frame should be sent.
-  bool ShouldSendBlocked();
+  // Sends a BLOCKED frame if needed.
+  void MaybeSendBlocked();
 
   // Returns true if flow control send limits have been reached.
   bool IsBlocked() const;

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

@@ -18,6 +18,7 @@
 
 using testing::_;
 using testing::Invoke;
+using testing::StrictMock;
 
 namespace quic {
 namespace test {
@@ -43,7 +44,7 @@ class QuicFlowControllerTest : public QuicTest {
     connection_->SetEncrypter(
         ENCRYPTION_FORWARD_SECURE,
         std::make_unique<NullEncrypter>(connection_->perspective()));
-    session_ = std::make_unique<MockQuicSession>(connection_);
+    session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
     flow_controller_ = std::make_unique<QuicFlowController>(
         session_.get(), stream_id_, /*is_connection_flow_controller*/ false,
         send_window_, receive_window_, kStreamReceiveWindowLimit,
@@ -58,7 +59,7 @@ class QuicFlowControllerTest : public QuicTest {
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicConnection* connection_;
-  std::unique_ptr<MockQuicSession> session_;
+  std::unique_ptr<StrictMock<MockQuicSession>> session_;
   MockFlowController session_flow_controller_;
   bool should_auto_tune_receive_window_ = false;
 };
@@ -81,7 +82,8 @@ TEST_F(QuicFlowControllerTest, SendingBytes) {
   EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 
   // BLOCKED frame should get sent.
-  EXPECT_TRUE(flow_controller_->ShouldSendBlocked());
+  EXPECT_CALL(*session_, SendBlocked(_, _)).Times(1);
+  flow_controller_->MaybeSendBlocked();
 
   // Update the send window, and verify this has unblocked.
   EXPECT_TRUE(flow_controller_->UpdateSendWindowOffset(2 * send_window_));
@@ -164,14 +166,16 @@ TEST_F(QuicFlowControllerTest, OnlySendBlockedFrameOncePerOffset) {
   EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 
   // BLOCKED frame should get sent.
-  EXPECT_TRUE(flow_controller_->ShouldSendBlocked());
+  EXPECT_CALL(*session_, SendBlocked(_, _)).Times(1);
+  flow_controller_->MaybeSendBlocked();
 
   // BLOCKED frame should not get sent again until our send offset changes.
-  EXPECT_FALSE(flow_controller_->ShouldSendBlocked());
-  EXPECT_FALSE(flow_controller_->ShouldSendBlocked());
-  EXPECT_FALSE(flow_controller_->ShouldSendBlocked());
-  EXPECT_FALSE(flow_controller_->ShouldSendBlocked());
-  EXPECT_FALSE(flow_controller_->ShouldSendBlocked());
+  EXPECT_CALL(*session_, SendBlocked(_, _)).Times(0);
+  flow_controller_->MaybeSendBlocked();
+  flow_controller_->MaybeSendBlocked();
+  flow_controller_->MaybeSendBlocked();
+  flow_controller_->MaybeSendBlocked();
+  flow_controller_->MaybeSendBlocked();
 
   // Update the send window, then send enough bytes to block again.
   EXPECT_TRUE(flow_controller_->UpdateSendWindowOffset(2 * send_window_));
@@ -182,7 +186,8 @@ TEST_F(QuicFlowControllerTest, OnlySendBlockedFrameOncePerOffset) {
   EXPECT_EQ(0u, flow_controller_->SendWindowSize());
 
   // BLOCKED frame should get sent as send offset has changed.
-  EXPECT_TRUE(flow_controller_->ShouldSendBlocked());
+  EXPECT_CALL(*session_, SendBlocked(_, _)).Times(1);
+  flow_controller_->MaybeSendBlocked();
 }
 
 TEST_F(QuicFlowControllerTest, ReceivingBytesFastIncreasesFlowWindow) {

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

@@ -5701,7 +5701,7 @@ bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
         ++num_ack_blocks_written;
       }
       if (num_ack_blocks_written >= num_ack_blocks) {
-        if (QUIC_PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) {
+        if (ABSL_PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) {
           QUIC_BUG(quic_bug_10850_85)
               << "Wrote " << num_ack_blocks_written << ", expected to write "
               << num_ack_blocks;

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

@@ -12,6 +12,7 @@
 
 #include <cstdint>
 
+#include "absl/base/optimization.h"
 #include "quiche/quic/core/quic_arena_scoped_ptr.h"
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
@@ -37,7 +38,7 @@ class QUIC_EXPORT_PRIVATE QuicOneBlockArena {
         << "Object is too large for the arena.";
     static_assert(alignof(T) > 1,
                   "Objects added to the arena must be at least 2B aligned.");
-    if (QUIC_PREDICT_FALSE(offset_ > ArenaSize - AlignedSize<T>())) {
+    if (ABSL_PREDICT_FALSE(offset_ > ArenaSize - AlignedSize<T>())) {
       QUIC_BUG(quic_bug_10593_1)
           << "Ran out of space in QuicOneBlockArena at " << this
           << ", max size was " << ArenaSize << ", failing request was "
@@ -69,7 +70,7 @@ class QUIC_EXPORT_PRIVATE QuicOneBlockArena {
 
 // QuicConnections currently use around 1KB of polymorphic types which would
 // ordinarily be on the heap. Instead, store them inline in an arena.
-using QuicConnectionArena = QuicOneBlockArena<1248>;
+using QuicConnectionArena = QuicOneBlockArena<1280>;
 
 }  // namespace quic
 

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

@@ -10,7 +10,7 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 static const uint32_t kMaxAlign = 8;
@@ -56,4 +56,4 @@ TEST_F(QuicOneBlockArenaTest, NoOverlaps) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

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

@@ -511,8 +511,7 @@ size_t QuicPacketCreator::ReserializeInitialPacketInCoalescedPacket(
       << "Attempt to serialize empty ENCRYPTION_INITIAL packet in coalesced "
          "packet";
 
-  if (close_connection_if_fail_to_serialzie_coalesced_packet_ &&
-      HasPendingFrames()) {
+  if (HasPendingFrames()) {
     QUIC_BUG(quic_packet_creator_unexpected_queued_frames)
         << "Unexpected queued frames: " << GetPendingFramesInfo();
     return 0;
@@ -549,15 +548,8 @@ size_t QuicPacketCreator::ReserializeInitialPacketInCoalescedPacket(
     }
   }
 
-  if (close_connection_if_fail_to_serialzie_coalesced_packet_) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(
-        quic_close_connection_if_fail_to_serialzie_coalesced_packet2, 1, 2);
-  }
-
-  if (!SerializePacket(
-          QuicOwnedPacketBuffer(buffer, nullptr), buffer_len,
-          /*allow_padding=*/
-          !close_connection_if_fail_to_serialzie_coalesced_packet_)) {
+  if (!SerializePacket(QuicOwnedPacketBuffer(buffer, nullptr), buffer_len,
+                       /*allow_padding=*/false)) {
     return 0;
   }
   const size_t encrypted_length = packet_.encrypted_length;

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

@@ -485,10 +485,6 @@ class QUIC_EXPORT_PRIVATE QuicPacketCreator {
 
   const QuicSocketAddress& peer_address() const { return packet_.peer_address; }
 
-  bool close_connection_if_fail_to_serialzie_coalesced_packet() const {
-    return close_connection_if_fail_to_serialzie_coalesced_packet_;
-  }
-
  private:
   friend class test::QuicPacketCreatorPeer;
 
@@ -692,10 +688,6 @@ class QUIC_EXPORT_PRIVATE QuicPacketCreator {
 
   // Whether to attempt protecting initial packets with chaos.
   bool chaos_protection_enabled_;
-
-  const bool close_connection_if_fail_to_serialzie_coalesced_packet_ =
-      GetQuicReloadableFlag(
-          quic_close_connection_if_fail_to_serialzie_coalesced_packet2);
 };
 
 }  // namespace quic

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

@@ -8,6 +8,11 @@ namespace quic {
 
 namespace {
 
+// Maximum shift used to calculate retransmittable on wire timeout. For 200ms
+// initial retransmittable on wire delay, this would get a maximum of 200ms * (1
+// << 10) = 204.8s
+const int kMaxRetransmittableOnWireDelayShift = 10;
+
 class AlarmDelegate : public QuicAlarm::DelegateWithContext {
  public:
   explicit AlarmDelegate(QuicPingManager* manager,
@@ -47,11 +52,6 @@ void QuicPingManager::SetAlarm(QuicTime now, bool should_keep_alive,
     return;
   }
   alarm_->Update(earliest_deadline, kAlarmGranularity);
-  if (GetQuicFlag(
-          FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count) != 0) {
-    ++consecutive_retransmittable_on_wire_count_;
-  }
-  ++retransmittable_on_wire_count_;
 }
 
 void QuicPingManager::OnAlarm() {
@@ -65,6 +65,12 @@ void QuicPingManager::OnAlarm() {
   // to SetAlarm later.
   if (earliest_deadline == retransmittable_on_wire_deadline_) {
     retransmittable_on_wire_deadline_ = QuicTime::Zero();
+    if (GetQuicFlag(
+            FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count) !=
+        0) {
+      ++consecutive_retransmittable_on_wire_count_;
+    }
+    ++retransmittable_on_wire_count_;
     delegate_->OnRetransmittableOnWireTimeout();
     return;
   }
@@ -125,8 +131,9 @@ void QuicPingManager::UpdateDeadlines(QuicTime now, bool should_keep_alive,
       max_aggressive_retransmittable_on_wire_count) {
     // Exponentially back off the timeout if the number of consecutive
     // retransmittable on wire pings has exceeds the allowance.
-    int shift = consecutive_retransmittable_on_wire_count_ -
-                max_aggressive_retransmittable_on_wire_count;
+    int shift = std::min(consecutive_retransmittable_on_wire_count_ -
+                             max_aggressive_retransmittable_on_wire_count,
+                         kMaxRetransmittableOnWireDelayShift);
     retransmittable_on_wire_timeout =
         initial_retransmittable_on_wire_timeout_ * (1 << shift);
   }
@@ -134,13 +141,6 @@ void QuicPingManager::UpdateDeadlines(QuicTime now, bool should_keep_alive,
       retransmittable_on_wire_deadline_ <
           now + retransmittable_on_wire_timeout) {
     // Alarm is set to an earlier time. Do not postpone it.
-    QUIC_BUG_IF(quic_retransmittable_on_wire_deadline_is_in_past,
-                retransmittable_on_wire_deadline_ < now)
-        << "QUIC retransmittable PING deadline is in past, now: "
-        << now.ToDebuggingValue() << ", retransmittable_on_wire_deadline: "
-        << retransmittable_on_wire_deadline_.ToDebuggingValue()
-        << ", difference: "
-        << (now - retransmittable_on_wire_deadline_).ToDebuggingValue();
     return;
   }
   retransmittable_on_wire_deadline_ = now + retransmittable_on_wire_timeout;

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

@@ -16,6 +16,11 @@ class QuicPingManagerPeer {
   static QuicAlarm* GetAlarm(QuicPingManager* manager) {
     return manager->alarm_.get();
   }
+
+  static void SetPerspective(QuicPingManager* manager,
+                             Perspective perspective) {
+    manager->perspective_ = perspective;
+  }
 };
 
 namespace {
@@ -292,6 +297,9 @@ TEST_F(QuicPingManagerTest,
                     !kHasInflightPackets);
   EXPECT_EQ(initial_retransmittable_on_wire_timeout,
             alarm_->deadline() - clock_.ApproximateNow());
+  EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+  clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
+  alarm_->Fire();
 
   for (int i = 0; i < kMaxAggressiveRetransmittableOnWireCount; i++) {
     manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
@@ -375,6 +383,46 @@ TEST_F(QuicPingManagerTest, RetransmittableOnWireLimit) {
   EXPECT_FALSE(alarm_->IsSet());
 }
 
+TEST_F(QuicPingManagerTest, MaxRetransmittableOnWireDelayShift) {
+  QuicPingManagerPeer::SetPerspective(&manager_, Perspective::IS_SERVER);
+  const int kMaxAggressiveRetransmittableOnWireCount = 3;
+  SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count,
+              kMaxAggressiveRetransmittableOnWireCount);
+  const QuicTime::Delta initial_retransmittable_on_wire_timeout =
+      QuicTime::Delta::FromMilliseconds(200);
+  manager_.set_initial_retransmittable_on_wire_timeout(
+      initial_retransmittable_on_wire_timeout);
+
+  for (int i = 0; i <= kMaxAggressiveRetransmittableOnWireCount; i++) {
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      !kHasInflightPackets);
+    EXPECT_TRUE(alarm_->IsSet());
+    EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+              alarm_->deadline() - clock_.ApproximateNow());
+    clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
+    EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+    alarm_->Fire();
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      kHasInflightPackets);
+  }
+  for (int i = 1; i <= 20; ++i) {
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      !kHasInflightPackets);
+    EXPECT_TRUE(alarm_->IsSet());
+    if (i <= 10) {
+      EXPECT_EQ(initial_retransmittable_on_wire_timeout * (1 << i),
+                alarm_->deadline() - clock_.ApproximateNow());
+    } else {
+      // Verify shift is capped.
+      EXPECT_EQ(initial_retransmittable_on_wire_timeout * (1 << 10),
+                alarm_->deadline() - clock_.ApproximateNow());
+    }
+    clock_.AdvanceTime(alarm_->deadline() - clock_.ApproximateNow());
+    EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+    alarm_->Fire();
+  }
+}
+
 }  // namespace
 
 }  // namespace test

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

@@ -267,24 +267,9 @@ void QuicReceivedPacketManager::MaybeUpdateAckTimeout(
     return;
   }
 
-  QuicTime ack_timeout_base = now;
-  const bool quic_update_ack_timeout_on_receipt_time =
-      GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time);
-  if (quic_update_ack_timeout_on_receipt_time) {
-    if (last_packet_receipt_time <= now) {
-      QUIC_CODE_COUNT(quic_update_ack_timeout_on_receipt_time);
-      ack_timeout_base = last_packet_receipt_time;
-    } else {
-      QUIC_CODE_COUNT(quic_update_ack_timeout_on_now);
-      ack_timeout_base = now;
-    }
-  }
-  QuicTime updated_ack_time =
-      ack_timeout_base +
-      GetMaxAckDelay(last_received_packet_number, *rtt_stats);
-  if (quic_update_ack_timeout_on_receipt_time) {
-    updated_ack_time = std::max(now, updated_ack_time);
-  }
+  const QuicTime updated_ack_time = std::max(
+      now, std::min(last_packet_receipt_time, now) +
+               GetMaxAckDelay(last_received_packet_number, *rtt_stats));
   if (!ack_timeout_.IsInitialized() || ack_timeout_ > updated_ack_time) {
     ack_timeout_ = updated_ack_time;
   }

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

@@ -650,13 +650,8 @@ TEST_F(QuicReceivedPacketManagerTest, UpdateAckTimeoutOnPacketReceiptTime) {
       kInstigateAck, QuicPacketNumber(3),
       /*last_packet_receipt_time=*/packet_receipt_time3,
       clock_.ApproximateNow(), &rtt_stats_);
-  if (GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time)) {
-    // Make sure ACK timeout is based on receipt time.
-    CheckAckTimeout(packet_receipt_time3 + kDelayedAckTime);
-  } else {
-    // Make sure ACK timeout is based on now.
-    CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
-  }
+  // Make sure ACK timeout is based on receipt time.
+  CheckAckTimeout(packet_receipt_time3 + kDelayedAckTime);
 
   RecordPacketReceipt(4, clock_.ApproximateNow());
   MaybeUpdateAckTimeout(kInstigateAck, 4);
@@ -677,13 +672,8 @@ TEST_F(QuicReceivedPacketManagerTest,
       kInstigateAck, QuicPacketNumber(3),
       /*last_packet_receipt_time=*/packet_receipt_time3,
       clock_.ApproximateNow(), &rtt_stats_);
-  if (GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time)) {
-    // Given 100ms > ack delay, verify immediate ACK.
-    CheckAckTimeout(clock_.ApproximateNow());
-  } else {
-    // Make sure ACK timeout is based on now.
-    CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
-  }
+  // Given 100ms > ack delay, verify immediate ACK.
+  CheckAckTimeout(clock_.ApproximateNow());
 }
 
 }  // namespace