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

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

@@ -128,7 +128,7 @@ class PingAlarmDelegate : public QuicConnectionAlarmDelegate {
 
   void OnAlarm() override {
     QUICHE_DCHECK(connection_->connected());
-    QUICHE_DCHECK(!GetQuicReloadableFlag(quic_use_ping_manager));
+    QUICHE_DCHECK(!GetQuicReloadableFlag(quic_use_ping_manager2));
     connection_->OnPingTimeout();
   }
 };
@@ -3014,15 +3014,8 @@ bool QuicConnection::ProcessValidatedPacket(const QuicPacketHeader& header) {
             ", encryption level: ",
             EncryptionLevelToString(
                 last_received_packet_info_.decrypted_level));
-        if (GetQuicReloadableFlag(
-                quic_drop_packets_with_changed_server_address)) {
-          QUIC_LOG_EVERY_N_SEC(INFO, 100) << error_details;
-          QUIC_CODE_COUNT(quic_dropped_packets_with_changed_server_address);
-          return false;
-        }
-        QUIC_PEER_BUG(Server self address change) << error_details;
-        CloseConnection(QUIC_ERROR_MIGRATING_ADDRESS, error_details,
-                        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+        QUIC_LOG_EVERY_N_SEC(INFO, 100) << error_details;
+        QUIC_CODE_COUNT(quic_dropped_packets_with_changed_server_address);
         return false;
       }
     }
@@ -4120,6 +4113,21 @@ void QuicConnection::SendAck() {
   visitor_->OnAckNeedsRetransmittableFrame();
 }
 
+EncryptionLevel QuicConnection::GetEncryptionLevelToSendPingForSpace(
+    PacketNumberSpace space) const {
+  switch (space) {
+    case INITIAL_DATA:
+      return ENCRYPTION_INITIAL;
+    case HANDSHAKE_DATA:
+      return ENCRYPTION_HANDSHAKE;
+    case APPLICATION_DATA:
+      return framer_.GetEncryptionLevelToSendApplicationData();
+    default:
+      QUICHE_DCHECK(false);
+      return NUM_ENCRYPTION_LEVELS;
+  }
+}
+
 void QuicConnection::OnRetransmissionTimeout() {
   ScopedRetransmissionTimeoutIndicator indicator(this);
 #ifndef NDEBUG
@@ -4182,7 +4190,8 @@ void QuicConnection::OnRetransmissionTimeout() {
       if (sent_packet_manager_
               .GetEarliestPacketSentTimeForPto(&packet_number_space)
               .IsInitialized()) {
-        SendPingAtLevel(QuicUtils::GetEncryptionLevel(packet_number_space));
+        SendPingAtLevel(
+            GetEncryptionLevelToSendPingForSpace(packet_number_space));
       } else {
         // The client must PTO when there is nothing in flight if the server
         // could be blocked from sending by the amplification limit
@@ -4686,7 +4695,7 @@ void QuicConnection::SetPingAlarm() {
     return;
   }
   if (use_ping_manager_) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_use_ping_manager);
+    QUIC_RELOADABLE_FLAG_COUNT(quic_use_ping_manager2);
     ping_manager_.SetAlarm(clock_->ApproximateNow(),
                            visitor_->ShouldKeepConnectionAlive(),
                            sent_packet_manager_.HasInFlightPackets());
@@ -4865,29 +4874,19 @@ QuicConnection::ScopedPacketFlusher::~ScopedPacketFlusher() {
       }
     }
 
-    if (connection_->flush_after_coalesce_higher_space_packets_) {
-      // INITIAL or HANDSHAKE retransmission could cause peer to derive new
-      // keys, such that the buffered undecryptable packets may be processed.
-      // This endpoint would derive an inflated RTT sample when receiving ACKs
-      // of those undecryptable packets. To mitigate this, tries to coalesce as
-      // many higher space packets as possible (via for loop inside
-      // MaybeCoalescePacketOfHigherSpace) to fill the remaining space in the
-      // coalescer.
-      QUIC_RELOADABLE_FLAG_COUNT(
-          quic_flush_after_coalesce_higher_space_packets);
-      if (connection_->version().CanSendCoalescedPackets()) {
-        connection_->MaybeCoalescePacketOfHigherSpace();
-      }
-      connection_->packet_creator_.Flush();
-      if (connection_->version().CanSendCoalescedPackets()) {
-        connection_->FlushCoalescedPacket();
-      }
-    } else {
-      connection_->packet_creator_.Flush();
-      if (connection_->version().CanSendCoalescedPackets()) {
-        connection_->MaybeCoalescePacketOfHigherSpace();
-        connection_->FlushCoalescedPacket();
-      }
+    // INITIAL or HANDSHAKE retransmission could cause peer to derive new
+    // keys, such that the buffered undecryptable packets may be processed.
+    // This endpoint would derive an inflated RTT sample when receiving ACKs
+    // of those undecryptable packets. To mitigate this, tries to coalesce as
+    // many higher space packets as possible (via for loop inside
+    // MaybeCoalescePacketOfHigherSpace) to fill the remaining space in the
+    // coalescer.
+    if (connection_->version().CanSendCoalescedPackets()) {
+      connection_->MaybeCoalescePacketOfHigherSpace();
+    }
+    connection_->packet_creator_.Flush();
+    if (connection_->version().CanSendCoalescedPackets()) {
+      connection_->FlushCoalescedPacket();
     }
     connection_->FlushPackets();
     if (!handshake_packet_sent_ && connection_->handshake_packet_sent_) {
@@ -5911,7 +5910,8 @@ void QuicConnection::SendAllPendingAcks() {
                   << PacketNumberSpaceToString(
                          static_cast<PacketNumberSpace>(i));
     ScopedEncryptionLevelContext context(
-        this, QuicUtils::GetEncryptionLevel(static_cast<PacketNumberSpace>(i)));
+        this, QuicUtils::GetEncryptionLevelToSendAckofSpace(
+                  static_cast<PacketNumberSpace>(i)));
     QuicFrames frames;
     frames.push_back(uber_received_packet_manager_.GetUpdatedAckFrame(
         static_cast<PacketNumberSpace>(i), clock_->ApproximateNow()));
@@ -5970,8 +5970,7 @@ void QuicConnection::MaybeCoalescePacketOfHigherSpace() {
   }
   if (fill_coalesced_packet_) {
     // Make sure MaybeCoalescePacketOfHigherSpace is not re-entrant.
-    QUIC_BUG_IF(quic_coalesce_packet_reentrant,
-                flush_after_coalesce_higher_space_packets_);
+    QUIC_BUG(quic_coalesce_packet_reentrant);
     return;
   }
   for (EncryptionLevel retransmission_level :
@@ -6025,11 +6024,7 @@ bool QuicConnection::FlushCoalescedPacket() {
   const size_t length = packet_creator_.SerializeCoalescedPacket(
       coalesced_packet_, buffer, coalesced_packet_.max_packet_length());
   if (length == 0) {
-    if (packet_creator_
-            .close_connection_if_fail_to_serialzie_coalesced_packet() &&
-        connected_) {
-      QUIC_RELOADABLE_FLAG_COUNT_N(
-          quic_close_connection_if_fail_to_serialzie_coalesced_packet2, 2, 2);
+    if (connected_) {
       CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET,
                       "Failed to serialize coalesced packet.",
                       ConnectionCloseBehavior::SILENT_CLOSE);
@@ -6927,11 +6922,38 @@ QuicConnectionId QuicConnection::GetOneActiveServerConnectionId() const {
 
 std::vector<QuicConnectionId> QuicConnection::GetActiveServerConnectionIds()
     const {
+  QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
+  std::vector<QuicConnectionId> result;
   if (self_issued_cid_manager_ == nullptr) {
-    return {default_path_.server_connection_id};
+    result.push_back(default_path_.server_connection_id);
+  } else {
+    QUICHE_DCHECK(version().HasIetfQuicFrames());
+    result = self_issued_cid_manager_->GetUnretiredConnectionIds();
   }
-  QUICHE_DCHECK(version().HasIetfQuicFrames());
-  return self_issued_cid_manager_->GetUnretiredConnectionIds();
+  if (GetQuicReloadableFlag(
+          quic_consider_original_connection_id_as_active_pre_handshake)) {
+    QUIC_RELOADABLE_FLAG_COUNT(
+        quic_consider_original_connection_id_as_active_pre_handshake);
+    if (!IsHandshakeComplete() &&
+        original_destination_connection_id_.has_value()) {
+      // Consider original_destination_connection_id_ as active before handshake
+      // completes.
+      if (std::find(result.begin(), result.end(),
+                    original_destination_connection_id_.value()) !=
+          result.end()) {
+        QUIC_BUG(quic_unexpected_original_destination_connection_id)
+            << "original_destination_connection_id: "
+            << original_destination_connection_id_.value()
+            << " is unexpectedly in active "
+               "list";
+      } else {
+        result.insert(result.end(),
+                      original_destination_connection_id_.value());
+      }
+      QUIC_CODE_COUNT(quic_active_original_connection_id_pre_handshake);
+    }
+  }
+  return result;
 }
 
 void QuicConnection::CreateConnectionIdManager() {

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

@@ -1863,6 +1863,10 @@ class QUIC_EXPORT_PRIVATE QuicConnection
   bool ShouldSetRetransmissionAlarmOnPacketSent(bool in_flight,
                                                 EncryptionLevel level) const;
 
+  // Determines encryption level to send ping in `packet_number_space`.
+  EncryptionLevel GetEncryptionLevelToSendPingForSpace(
+      PacketNumberSpace space) const;
+
   QuicConnectionContext context_;
 
   QuicFramer framer_;
@@ -1991,7 +1995,7 @@ class QUIC_EXPORT_PRIVATE QuicConnection
   bool defer_send_in_response_to_packets_;
 
   // TODO(fayang): remove PING related fields below when deprecating
-  // quic_use_ping_manager.
+  // quic_use_ping_manager2.
   // The timeout for keep-alive PING.
   QuicTime::Delta keep_alive_ping_timeout_;
 
@@ -2015,7 +2019,7 @@ class QUIC_EXPORT_PRIVATE QuicConnection
   // An alarm that is scheduled when the SentPacketManager requires a delay
   // before sending packets and fires when the packet may be sent.
   QuicArenaScopedPtr<QuicAlarm> send_alarm_;
-  // TODO(fayang): remove ping_alarm_ when deprecating quic_use_ping_manager.
+  // TODO(fayang): remove ping_alarm_ when deprecating quic_use_ping_manager2.
   // An alarm that fires when a ping should be sent.
   QuicArenaScopedPtr<QuicAlarm> ping_alarm_;
   // An alarm that fires when an MTU probe should be sent.
@@ -2246,13 +2250,10 @@ class QUIC_EXPORT_PRIVATE QuicConnection
   // Enable this via reloadable flag once this feature is complete.
   bool connection_migration_use_new_cid_ = false;
 
-  const bool flush_after_coalesce_higher_space_packets_ =
-      GetQuicReloadableFlag(quic_flush_after_coalesce_higher_space_packets);
-
   // If true, send connection close packet on INVALID_VERSION.
   bool send_connection_close_for_invalid_version_ = false;
 
-  const bool use_ping_manager_ = GetQuicReloadableFlag(quic_use_ping_manager);
+  const bool use_ping_manager_ = GetQuicReloadableFlag(quic_use_ping_manager2);
 
   QuicPingManager ping_manager_;
 

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

@@ -9,7 +9,7 @@
 
 using testing::ElementsAre;
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 class TraceCollector : public QuicConnectionTracer {
@@ -170,4 +170,4 @@ TEST_F(QuicConnectionContextTest, TestAlternatingSwitch) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

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

@@ -13,7 +13,7 @@
 #include "quiche/quic/test_tools/quic_connection_id_manager_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 using ::quic::test::IsError;
@@ -953,4 +953,4 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

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

@@ -13,7 +13,7 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
 
-namespace quic {
+namespace quic::test {
 
 namespace {
 
@@ -178,4 +178,4 @@ TEST_F(QuicConnectionIdTest, ChangeLength) {
 
 }  // namespace
 
-}  // namespace quic
+}  // namespace quic::test

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

@@ -1563,23 +1563,9 @@ TEST_P(QuicConnectionTest, SelfAddressChangeAtServer) {
   QuicSocketAddress self_address(host, 123);
   EXPECT_EQ(0u, connection_.GetStats().packets_dropped);
   EXPECT_CALL(visitor_, AllowSelfAddressChange()).WillOnce(Return(false));
-  if (GetQuicReloadableFlag(quic_drop_packets_with_changed_server_address)) {
-    ProcessFramePacketWithAddresses(MakeCryptoFrame(), self_address,
-                                    kPeerAddress, ENCRYPTION_INITIAL);
-    EXPECT_TRUE(connection_.connected());
-    EXPECT_EQ(1u, connection_.GetStats().packets_dropped);
-    return;
-  }
-  if (version().handshake_protocol == PROTOCOL_TLS1_3) {
-    EXPECT_CALL(visitor_, BeforeConnectionCloseSent());
-  }
-  EXPECT_CALL(visitor_, OnConnectionClosed(_, _));
-  EXPECT_QUIC_PEER_BUG(
-      ProcessFramePacketWithAddresses(MakeCryptoFrame(), self_address,
-                                      kPeerAddress, ENCRYPTION_INITIAL),
-      "Self address migration is not supported at the server");
-  EXPECT_FALSE(connection_.connected());
-  TestConnectionCloseQuicErrorCode(QUIC_ERROR_MIGRATING_ADDRESS);
+  ProcessFramePacketWithAddresses(MakeCryptoFrame(), self_address, kPeerAddress,
+                                  ENCRYPTION_INITIAL);
+  EXPECT_TRUE(connection_.connected());
   EXPECT_EQ(1u, connection_.GetStats().packets_dropped);
 }
 
@@ -6945,7 +6931,7 @@ TEST_P(QuicConnectionTest, SendBlockedImmediately) {
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   EXPECT_CALL(debug_visitor, OnPacketSent(_, _, _, _, _, _, _, _)).Times(1);
   EXPECT_EQ(0u, connection_.GetStats().blocked_frames_sent);
-  connection_.SendControlFrame(QuicFrame(QuicBlockedFrame(1, 3)));
+  connection_.SendControlFrame(QuicFrame(QuicBlockedFrame(1, 3, 0)));
   EXPECT_EQ(1u, connection_.GetStats().blocked_frames_sent);
   EXPECT_FALSE(connection_.HasQueuedData());
 }
@@ -6956,7 +6942,7 @@ TEST_P(QuicConnectionTest, FailedToSendBlockedFrames) {
   }
   MockQuicConnectionDebugVisitor debug_visitor;
   connection_.set_debug_visitor(&debug_visitor);
-  QuicBlockedFrame blocked(1, 3);
+  QuicBlockedFrame blocked(1, 3, 0);
 
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   EXPECT_CALL(debug_visitor, OnPacketSent(_, _, _, _, _, _, _, _)).Times(0);
@@ -7185,7 +7171,7 @@ TEST_P(QuicConnectionTest, ServerRetransmittableOnWire) {
 }
 
 TEST_P(QuicConnectionTest, RetransmittableOnWireSendFirstPacket) {
-  if (!GetQuicReloadableFlag(quic_use_ping_manager) ||
+  if (!GetQuicReloadableFlag(quic_use_ping_manager2) ||
       !VersionHasIetfQuicFrames(connection_.version().transport_version)) {
     return;
   }
@@ -7231,7 +7217,7 @@ TEST_P(QuicConnectionTest, RetransmittableOnWireSendFirstPacket) {
 }
 
 TEST_P(QuicConnectionTest, RetransmittableOnWireSendRandomBytes) {
-  if (!GetQuicReloadableFlag(quic_use_ping_manager) ||
+  if (!GetQuicReloadableFlag(quic_use_ping_manager2) ||
       !VersionHasIetfQuicFrames(connection_.version().transport_version)) {
     return;
   }
@@ -7280,7 +7266,7 @@ TEST_P(QuicConnectionTest, RetransmittableOnWireSendRandomBytes) {
 
 TEST_P(QuicConnectionTest,
        RetransmittableOnWireSendRandomBytesWithWriterBlocked) {
-  if (!GetQuicReloadableFlag(quic_use_ping_manager) ||
+  if (!GetQuicReloadableFlag(quic_use_ping_manager2) ||
       !VersionHasIetfQuicFrames(connection_.version().transport_version)) {
     return;
   }
@@ -8250,6 +8236,8 @@ TEST_P(QuicConnectionTest, ResetBackOffRetransmitableOnWireTimeout) {
                                          peer_creator_.packet_number() + 1);
   EXPECT_EQ(initial_retransmittable_on_wire_timeout,
             connection_.GetPingAlarm()->deadline() - clock_.ApproximateNow());
+  clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
+  connection_.GetPingAlarm()->Fire();
 
   // Verify the count of consecutive aggressive pings is reset.
   for (int i = 0; i < max_aggressive_retransmittable_on_wire_ping_count; i++) {
@@ -9276,14 +9264,14 @@ TEST_P(QuicConnectionTest, CoalescedPacketThatSavesFrames) {
         .Times(3)
         .WillRepeatedly([this](const QuicCryptoFrame& /*frame*/) {
           // QuicFrame takes ownership of the QuicBlockedFrame.
-          connection_.SendControlFrame(QuicFrame(QuicBlockedFrame(1, 3)));
+          connection_.SendControlFrame(QuicFrame(QuicBlockedFrame(1, 3, 0)));
         });
   } else {
     EXPECT_CALL(visitor_, OnStreamFrame(_))
         .Times(3)
         .WillRepeatedly([this](const QuicStreamFrame& /*frame*/) {
           // QuicFrame takes ownership of the QuicBlockedFrame.
-          connection_.SendControlFrame(QuicFrame(QuicBlockedFrame(1, 3)));
+          connection_.SendControlFrame(QuicFrame(QuicBlockedFrame(1, 3, 0)));
         });
   }
 
@@ -9919,12 +9907,8 @@ TEST_P(QuicConnectionTest, FailToCoalescePacket) {
 
   EXPECT_CALL(visitor_, OnHandshakePacketSent());
 
-  if (GetQuicReloadableFlag(
-          quic_close_connection_if_fail_to_serialzie_coalesced_packet2)) {
-    EXPECT_CALL(visitor_,
-                OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF))
-        .WillOnce(Invoke(this, &QuicConnectionTest::SaveConnectionCloseFrame));
-  }
+  EXPECT_CALL(visitor_, OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF))
+      .WillOnce(Invoke(this, &QuicConnectionTest::SaveConnectionCloseFrame));
 
   ProcessDataPacketAtLevel(1, !kHasStopWaiting, ENCRYPTION_INITIAL);
   auto test_body = [&] {
@@ -9970,16 +9954,11 @@ TEST_P(QuicConnectionTest, FailToCoalescePacket) {
 
   EXPECT_QUIC_BUG(test_body(), "SerializeCoalescedPacket failed.");
 
-  if (GetQuicReloadableFlag(
-          quic_close_connection_if_fail_to_serialzie_coalesced_packet2)) {
-    EXPECT_FALSE(connection_.connected());
-    EXPECT_THAT(saved_connection_close_frame_.quic_error_code,
-                IsError(QUIC_FAILED_TO_SERIALIZE_PACKET));
-    EXPECT_EQ(saved_connection_close_frame_.error_details,
-              "Failed to serialize coalesced packet.");
-  } else {
-    EXPECT_TRUE(connection_.connected());
-  }
+  EXPECT_FALSE(connection_.connected());
+  EXPECT_THAT(saved_connection_close_frame_.quic_error_code,
+              IsError(QUIC_FAILED_TO_SERIALIZE_PACKET));
+  EXPECT_EQ(saved_connection_close_frame_.error_details,
+            "Failed to serialize coalesced packet.");
 }
 
 TEST_P(QuicConnectionTest, LegacyVersionEncapsulation) {
@@ -11203,40 +11182,13 @@ TEST_P(QuicConnectionTest, ClientAckDelayForAsyncPacketProcessing) {
                            std::make_unique<TaggingEncrypter>(0x01));
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_HANDSHAKE);
   // Verify HANDSHAKE packet gets processed.
-  if (GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time)) {
-    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
-  } else {
-    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
-  }
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   connection_.GetProcessUndecryptablePacketsAlarm()->Fire();
-  if (GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time)) {
-    // Verify immediate ACK has been sent out when flush went out of scope.
-    ASSERT_FALSE(connection_.HasPendingAcks());
-  } else {
-    ASSERT_TRUE(connection_.HasPendingAcks());
-    // Send ACKs.
-    clock_.AdvanceTime(connection_.GetAckAlarm()->deadline() - clock_.Now());
-    connection_.GetAckAlarm()->Fire();
-  }
+  // Verify immediate ACK has been sent out when flush went out of scope.
+  ASSERT_FALSE(connection_.HasPendingAcks());
   ASSERT_FALSE(writer_->ack_frames().empty());
-  if (GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time)) {
-    // Verify the ack_delay_time in the sent HANDSHAKE ACK frame is 100ms.
-    EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
-              writer_->ack_frames()[0].ack_delay_time);
-    ASSERT_TRUE(writer_->coalesced_packet() == nullptr);
-    return;
-  }
-  // Verify the ack_delay_time in the INITIAL ACK frame is 1ms.
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(1),
-            writer_->ack_frames()[0].ack_delay_time);
-  // Process the coalesced HANDSHAKE packet.
-  ASSERT_TRUE(writer_->coalesced_packet() != nullptr);
-  auto packet = writer_->coalesced_packet()->Clone();
-  writer_->framer()->ProcessPacket(*packet);
-  ASSERT_FALSE(writer_->ack_frames().empty());
-  // Verify the ack_delay_time in the HANDSHAKE ACK frame includes the
-  // buffering time.
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(101),
+  // Verify the ack_delay_time in the sent HANDSHAKE ACK frame is 100ms.
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
             writer_->ack_frames()[0].ack_delay_time);
   ASSERT_TRUE(writer_->coalesced_packet() == nullptr);
 }
@@ -14999,21 +14951,12 @@ TEST_P(QuicConnectionTest, FailedToRetransmitShlo) {
             connection_.GetAckAlarm()->deadline());
   // ACK is not throttled by amplification limit, and SHLO is bundled. Also
   // HANDSHAKE + 1RTT packets get coalesced.
-  if (GetQuicReloadableFlag(quic_flush_after_coalesce_higher_space_packets)) {
-    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
-  } else {
-    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
-  }
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
   // ACK alarm fires.
   clock_.AdvanceTime(kAlarmGranularity);
   connection_.GetAckAlarm()->Fire();
-  if (GetQuicReloadableFlag(quic_flush_after_coalesce_higher_space_packets)) {
-    // Verify 1-RTT packet is coalesced.
-    EXPECT_EQ(0x04040404u, writer_->final_bytes_of_last_packet());
-  } else {
-    // Verify HANDSHAKE packet is coalesced with INITIAL ACK + SHLO.
-    EXPECT_EQ(0x03030303u, writer_->final_bytes_of_last_packet());
-  }
+  // Verify 1-RTT packet is coalesced.
+  EXPECT_EQ(0x04040404u, writer_->final_bytes_of_last_packet());
   // Only the first packet in the coalesced packet has been processed,
   // verify SHLO is bundled with INITIAL ACK.
   EXPECT_EQ(1u, writer_->ack_frames().size());
@@ -15024,16 +14967,12 @@ TEST_P(QuicConnectionTest, FailedToRetransmitShlo) {
   writer_->framer()->ProcessPacket(*packet);
   EXPECT_EQ(0u, writer_->ack_frames().size());
   EXPECT_EQ(1u, writer_->crypto_frames().size());
-  if (GetQuicReloadableFlag(quic_flush_after_coalesce_higher_space_packets)) {
-    // Process the coalesced 1-RTT packet.
-    ASSERT_TRUE(writer_->coalesced_packet() != nullptr);
-    packet = writer_->coalesced_packet()->Clone();
-    writer_->framer()->ProcessPacket(*packet);
-    EXPECT_EQ(0u, writer_->crypto_frames().size());
-    EXPECT_EQ(1u, writer_->stream_frames().size());
-  } else {
-    ASSERT_TRUE(writer_->coalesced_packet() == nullptr);
-  }
+  // Process the coalesced 1-RTT packet.
+  ASSERT_TRUE(writer_->coalesced_packet() != nullptr);
+  packet = writer_->coalesced_packet()->Clone();
+  writer_->framer()->ProcessPacket(*packet);
+  EXPECT_EQ(0u, writer_->crypto_frames().size());
+  EXPECT_EQ(1u, writer_->stream_frames().size());
 
   // Received INITIAL 3.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
@@ -15272,22 +15211,12 @@ TEST_P(QuicConnectionTest, NoExtraPaddingInReserializedInitial) {
   // Server receives INITIAL 3, this will serialzie FS 7 (stream 4, stream 8),
   // which will trigger a flush of a coalesced packet consists of INITIAL 4,
   // HS 5 and FS 6 (stream 4).
-  if (GetQuicReloadableFlag(
-          quic_close_connection_if_fail_to_serialzie_coalesced_packet2)) {
-    // Expect no QUIC_BUG.
-    ProcessDataPacketAtLevel(3, !kHasStopWaiting, ENCRYPTION_INITIAL);
-    EXPECT_EQ(
-        debug_visitor_sent_count,
-        connection_.sent_packet_manager().GetLargestSentPacket().ToUint64());
-  } else {
-    // Expect QUIC_BUG due to extra padding.
-    EXPECT_QUIC_BUG(
-        { ProcessDataPacketAtLevel(3, !kHasStopWaiting, ENCRYPTION_INITIAL); },
-        "Reserialize initial packet in coalescer has unexpected size");
-    EXPECT_EQ(
-        debug_visitor_sent_count + 1,
-        connection_.sent_packet_manager().GetLargestSentPacket().ToUint64());
-  }
+
+  // Expect no QUIC_BUG.
+  ProcessDataPacketAtLevel(3, !kHasStopWaiting, ENCRYPTION_INITIAL);
+  EXPECT_EQ(
+      debug_visitor_sent_count,
+      connection_.sent_packet_manager().GetLargestSentPacket().ToUint64());
 
   // The error only happens if after serializing the second 1RTT packet(pkt #7),
   // the pending padding bytes is non zero.
@@ -15339,27 +15268,15 @@ TEST_P(QuicConnectionTest, ReportedAckDelayIncludesQueuingDelay) {
 
   connection_.GetProcessUndecryptablePacketsAlarm()->Fire();
   ASSERT_TRUE(connection_.HasPendingAcks());
-  if (GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time)) {
-    EXPECT_EQ(packet_receipt_time + DefaultDelayedAckTime(),
-              connection_.GetAckAlarm()->deadline());
-    clock_.AdvanceTime(packet_receipt_time + DefaultDelayedAckTime() -
-                       clock_.Now());
-  } else {
-    EXPECT_EQ(clock_.Now() + DefaultDelayedAckTime(),
-              connection_.GetAckAlarm()->deadline());
-    clock_.AdvanceTime(DefaultDelayedAckTime());
-  }
+  EXPECT_EQ(packet_receipt_time + DefaultDelayedAckTime(),
+            connection_.GetAckAlarm()->deadline());
+  clock_.AdvanceTime(packet_receipt_time + DefaultDelayedAckTime() -
+                     clock_.Now());
   // Fire ACK alarm.
   connection_.GetAckAlarm()->Fire();
   ASSERT_EQ(1u, writer_->ack_frames().size());
-  if (GetQuicReloadableFlag(quic_update_ack_timeout_on_receipt_time)) {
-    // Verify ACK delay time does not include queuing delay.
-    EXPECT_EQ(DefaultDelayedAckTime(), writer_->ack_frames()[0].ack_delay_time);
-  } else {
-    // Verify ACK delay time = queuing delay + ack delay
-    EXPECT_EQ(DefaultDelayedAckTime() + kQueuingDelay,
-              writer_->ack_frames()[0].ack_delay_time);
-  }
+  // Verify ACK delay time does not include queuing delay.
+  EXPECT_EQ(DefaultDelayedAckTime(), writer_->ack_frames()[0].ack_delay_time);
 }
 
 TEST_P(QuicConnectionTest, CoalesceOneRTTPacketWithInitialAndHandshakePackets) {
@@ -15424,10 +15341,6 @@ TEST_P(QuicConnectionTest, CoalesceOneRTTPacketWithInitialAndHandshakePackets) {
   auto packet = writer_->coalesced_packet()->Clone();
   writer_->framer()->ProcessPacket(*packet);
   EXPECT_EQ(1u, writer_->crypto_frames().size());
-  if (!GetQuicReloadableFlag(quic_flush_after_coalesce_higher_space_packets)) {
-    ASSERT_TRUE(writer_->coalesced_packet() == nullptr);
-    return;
-  }
   // Process 1-RTT packet.
   ASSERT_TRUE(writer_->coalesced_packet() != nullptr);
   packet = writer_->coalesced_packet()->Clone();

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

@@ -307,13 +307,6 @@ QUIC_EXPORT_PRIVATE QuicPacketNumber FirstSendingPacketNumber();
 QUIC_EXPORT_PRIVATE extern const char* const kEPIDGoogleFrontEnd;
 QUIC_EXPORT_PRIVATE extern const char* const kEPIDGoogleFrontEnd0;
 
-// HTTP/3 Datagrams.
-enum : QuicDatagramContextId {
-  kFirstDatagramContextIdClient = 0,
-  kFirstDatagramContextIdServer = 1,
-  kDatagramContextIdIncrement = 2,
-};
-
 enum : uint64_t {
   kHttpDatagramStreamIdDivisor = 4,
 };

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

@@ -17,6 +17,7 @@
 #include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
 #include "quiche/quic/platform/api/quic_flag_utils.h"
+#include "quiche/quic/platform/api/quic_flags.h"
 
 namespace quic {
 
@@ -81,10 +82,17 @@ void QuicControlFrameManager::WriteOrBufferWindowUpdate(
       QuicWindowUpdateFrame(++last_control_frame_id_, id, byte_offset)));
 }
 
-void QuicControlFrameManager::WriteOrBufferBlocked(QuicStreamId id) {
+void QuicControlFrameManager::WriteOrBufferBlocked(
+    QuicStreamId id, QuicStreamOffset byte_offset) {
   QUIC_DVLOG(1) << "Writing BLOCKED_FRAME";
-  WriteOrBufferQuicFrame(
-      QuicFrame(QuicBlockedFrame(++last_control_frame_id_, id)));
+  if (GetQuicReloadableFlag(quic_include_offset_in_blocked_frames)) {
+    QUIC_RELOADABLE_FLAG_COUNT(quic_include_offset_in_blocked_frames);
+    WriteOrBufferQuicFrame(
+        QuicFrame(QuicBlockedFrame(++last_control_frame_id_, id, byte_offset)));
+  } else {
+    WriteOrBufferQuicFrame(
+        QuicFrame(QuicBlockedFrame(++last_control_frame_id_, id, 0)));
+  }
 }
 
 void QuicControlFrameManager::WriteOrBufferStreamsBlocked(QuicStreamCount count,

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

@@ -69,7 +69,7 @@ class QUIC_EXPORT_PRIVATE QuicControlFrameManager {
 
   // Tries to send a BLOCKED_FRAME. Buffers the frame if it cannot be sent
   // immediately.
-  void WriteOrBufferBlocked(QuicStreamId id);
+  void WriteOrBufferBlocked(QuicStreamId id, QuicStreamOffset byte_offset);
 
   // Tries to send a STREAMS_BLOCKED Frame. Buffers the frame if it cannot be
   // sent immediately.

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

@@ -72,7 +72,7 @@ class QuicControlFrameManagerTest : public QuicTest {
     manager_->WriteOrBufferGoAway(QUIC_PEER_GOING_AWAY, kTestStreamId,
                                   "Going away.");
     manager_->WriteOrBufferWindowUpdate(kTestStreamId, 100);
-    manager_->WriteOrBufferBlocked(kTestStreamId);
+    manager_->WriteOrBufferBlocked(kTestStreamId, 0);
     manager_->WriteOrBufferStopSending(
         QuicResetStreamError::FromInternal(kTestStopSendingCode),
         kTestStreamId);
@@ -93,7 +93,7 @@ class QuicControlFrameManagerTest : public QuicTest {
   QuicGoAwayFrame goaway_ = {2, QUIC_PEER_GOING_AWAY, kTestStreamId,
                              "Going away."};
   QuicWindowUpdateFrame window_update_ = {3, kTestStreamId, 100};
-  QuicBlockedFrame blocked_ = {4, kTestStreamId};
+  QuicBlockedFrame blocked_ = {4, kTestStreamId, 0};
   QuicStopSendingFrame stop_sending_ = {5, kTestStreamId, kTestStopSendingCode};
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;