@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/quiche/quiche/quic/core/io/quic_poll_event_loop_test.cc

@@ -0,0 +1,341 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/core/io/quic_poll_event_loop.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <memory>
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/mock_clock.h"
+
+namespace quic {
+
+class QuicPollEventLoopPeer {
+ public:
+  static QuicTime::Delta ComputePollTimeout(const QuicPollEventLoop& loop,
+                                            QuicTime now,
+                                            QuicTime::Delta default_timeout) {
+    return loop.ComputePollTimeout(now, default_timeout);
+  }
+};
+
+}  // namespace quic
+
+namespace quic::test {
+namespace {
+
+using testing::_;
+using testing::AtMost;
+using testing::ElementsAre;
+
+constexpr QuicSocketEventMask kAllEvents =
+    kSocketEventReadable | kSocketEventWritable | kSocketEventError;
+constexpr QuicTime::Delta kDefaultTimeout = QuicTime::Delta::FromSeconds(100);
+
+class MockQuicSocketEventListener : public QuicSocketEventListener {
+ public:
+  MOCK_METHOD(void, OnSocketEvent,
+              (QuicEventLoop* /*event_loop*/, QuicUdpSocketFd /*fd*/,
+               QuicSocketEventMask /*events*/),
+              (override));
+};
+
+class MockDelegate : public QuicAlarm::Delegate {
+ public:
+  QuicConnectionContext* GetConnectionContext() override { return nullptr; }
+  MOCK_METHOD(void, OnAlarm, (), (override));
+};
+
+class QuicPollEventLoopForTest : public QuicPollEventLoop {
+ public:
+  QuicPollEventLoopForTest(MockClock* clock)
+      : QuicPollEventLoop(clock), clock_(clock) {}
+
+  int PollSyscall(pollfd* fds, nfds_t nfds, int timeout) override {
+    timeouts_.push_back(timeout);
+    if (eintr_after_ != QuicTime::Delta::Infinite()) {
+      errno = EINTR;
+      clock_->AdvanceTime(eintr_after_);
+      eintr_after_ = QuicTime::Delta::Infinite();
+      return -1;
+    }
+    clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(timeout));
+    return QuicPollEventLoop::PollSyscall(fds, nfds, timeout);
+  }
+
+  void TriggerEintrAfter(QuicTime::Delta time) { eintr_after_ = time; }
+
+  const std::vector<int>& timeouts() const { return timeouts_; }
+
+ private:
+  MockClock* clock_;
+  QuicTime::Delta eintr_after_ = QuicTime::Delta::Infinite();
+  std::vector<int> timeouts_;
+};
+
+class QuicPollEventLoopTest : public QuicTest {
+ public:
+  QuicPollEventLoopTest() : loop_(&clock_), factory_(loop_.GetAlarmFactory()) {
+    int fds[2];
+    int result = ::pipe(fds);
+    QUICHE_CHECK(result >= 0) << "Failed to create a pipe, errno: " << errno;
+    read_fd_ = fds[0];
+    write_fd_ = fds[1];
+
+    QUICHE_CHECK(::fcntl(read_fd_, F_SETFL,
+                         ::fcntl(read_fd_, F_GETFL) | O_NONBLOCK) == 0)
+        << "Failed to mark pipe FD non-blocking, errno: " << errno;
+    QUICHE_CHECK(::fcntl(write_fd_, F_SETFL,
+                         ::fcntl(write_fd_, F_GETFL) | O_NONBLOCK) == 0)
+        << "Failed to mark pipe FD non-blocking, errno: " << errno;
+
+    clock_.AdvanceTime(10 * kDefaultTimeout);
+  }
+
+  ~QuicPollEventLoopTest() {
+    close(read_fd_);
+    close(write_fd_);
+  }
+
+  QuicTime::Delta ComputePollTimeout() {
+    return QuicPollEventLoopPeer::ComputePollTimeout(loop_, clock_.Now(),
+                                                     kDefaultTimeout);
+  }
+
+  std::pair<std::unique_ptr<QuicAlarm>, MockDelegate*> CreateAlarm() {
+    auto delegate = std::make_unique<testing::StrictMock<MockDelegate>>();
+    MockDelegate* delegate_unowned = delegate.get();
+    auto alarm = absl::WrapUnique(factory_->CreateAlarm(delegate.release()));
+    return std::make_pair(std::move(alarm), delegate_unowned);
+  }
+
+ protected:
+  MockClock clock_;
+  QuicPollEventLoopForTest loop_;
+  QuicAlarmFactory* factory_;
+  int read_fd_;
+  int write_fd_;
+};
+
+TEST_F(QuicPollEventLoopTest, NothingHappens) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(read_fd_, kAllEvents, &listener));
+  ASSERT_TRUE(loop_.RegisterSocket(write_fd_, kAllEvents, &listener));
+
+  // Attempt double-registration.
+  EXPECT_FALSE(loop_.RegisterSocket(write_fd_, kAllEvents, &listener));
+
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+
+  EXPECT_CALL(listener, OnSocketEvent(_, write_fd_, kSocketEventWritable));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(4));
+  // Expect no further calls.
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(5));
+  EXPECT_THAT(loop_.timeouts(), ElementsAre(4, 5));
+}
+
+TEST_F(QuicPollEventLoopTest, RearmWriter) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(write_fd_, kAllEvents, &listener));
+
+  EXPECT_CALL(listener, OnSocketEvent(_, write_fd_, kSocketEventWritable))
+      .Times(2);
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+  ASSERT_TRUE(loop_.RearmSocket(write_fd_, kSocketEventWritable));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+}
+
+TEST_F(QuicPollEventLoopTest, Readable) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(read_fd_, kAllEvents, &listener));
+
+  ASSERT_EQ(4, write(write_fd_, "test", 4));
+  EXPECT_CALL(listener, OnSocketEvent(_, read_fd_, kSocketEventReadable));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+  // Expect no further calls.
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+}
+
+TEST_F(QuicPollEventLoopTest, RearmReader) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(read_fd_, kAllEvents, &listener));
+
+  ASSERT_EQ(4, write(write_fd_, "test", 4));
+  EXPECT_CALL(listener, OnSocketEvent(_, read_fd_, kSocketEventReadable));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+  // Expect no further calls.
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+}
+
+TEST_F(QuicPollEventLoopTest, WriterUnblocked) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(write_fd_, kAllEvents, &listener));
+
+  EXPECT_CALL(listener, OnSocketEvent(_, write_fd_, kSocketEventWritable));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+
+  int io_result;
+  std::string data(2048, 'a');
+  do {
+    io_result = write(write_fd_, data.data(), data.size());
+  } while (io_result > 0);
+  ASSERT_EQ(errno, EAGAIN);
+
+  // Rearm and expect no immediate calls.
+  ASSERT_TRUE(loop_.RearmSocket(write_fd_, kSocketEventWritable));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+
+  EXPECT_CALL(listener, OnSocketEvent(_, write_fd_, kSocketEventWritable));
+  do {
+    io_result = read(read_fd_, data.data(), data.size());
+  } while (io_result > 0);
+  ASSERT_EQ(errno, EAGAIN);
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+}
+
+TEST_F(QuicPollEventLoopTest, ArtificialEvent) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(read_fd_, kAllEvents, &listener));
+  ASSERT_TRUE(loop_.RegisterSocket(write_fd_, kAllEvents, &listener));
+
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+  ASSERT_TRUE(loop_.ArtificiallyNotifyEvent(read_fd_, kSocketEventReadable));
+  EXPECT_EQ(ComputePollTimeout(), QuicTime::Delta::Zero());
+
+  {
+    testing::InSequence s;
+    EXPECT_CALL(listener, OnSocketEvent(_, read_fd_, kSocketEventReadable));
+    EXPECT_CALL(listener, OnSocketEvent(_, write_fd_, kSocketEventWritable));
+  }
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+}
+
+TEST_F(QuicPollEventLoopTest, Unregister) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(write_fd_, kAllEvents, &listener));
+  ASSERT_TRUE(loop_.UnregisterSocket(write_fd_));
+
+  // Expect nothing to happen.
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+
+  EXPECT_FALSE(loop_.UnregisterSocket(write_fd_));
+  EXPECT_FALSE(loop_.RearmSocket(write_fd_, kSocketEventWritable));
+  EXPECT_FALSE(loop_.ArtificiallyNotifyEvent(write_fd_, kSocketEventWritable));
+}
+
+TEST_F(QuicPollEventLoopTest, UnregisterInsideEventHandler) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(read_fd_, kAllEvents, &listener));
+  ASSERT_TRUE(loop_.RegisterSocket(write_fd_, kAllEvents, &listener));
+
+  EXPECT_CALL(listener, OnSocketEvent(_, read_fd_, kSocketEventReadable))
+      .WillOnce([this]() { ASSERT_TRUE(loop_.UnregisterSocket(write_fd_)); });
+  EXPECT_CALL(listener, OnSocketEvent(_, write_fd_, kSocketEventWritable))
+      .Times(0);
+  ASSERT_TRUE(loop_.ArtificiallyNotifyEvent(read_fd_, kSocketEventReadable));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(1));
+}
+
+TEST_F(QuicPollEventLoopTest, EintrHandler) {
+  testing::StrictMock<MockQuicSocketEventListener> listener;
+  ASSERT_TRUE(loop_.RegisterSocket(read_fd_, kAllEvents, &listener));
+
+  loop_.TriggerEintrAfter(QuicTime::Delta::FromMilliseconds(25));
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(100));
+  EXPECT_THAT(loop_.timeouts(), ElementsAre(100, 75));
+}
+
+TEST_F(QuicPollEventLoopTest, AlarmInFuture) {
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+
+  constexpr auto kAlarmTimeout = QuicTime::Delta::FromMilliseconds(5);
+  auto [alarm, delegate] = CreateAlarm();
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+
+  alarm->Set(clock_.Now() + kAlarmTimeout);
+  EXPECT_EQ(ComputePollTimeout(), kAlarmTimeout);
+
+  EXPECT_CALL(*delegate, OnAlarm());
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(100));
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+}
+
+TEST_F(QuicPollEventLoopTest, AlarmsInPast) {
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+
+  constexpr auto kAlarmTimeout = QuicTime::Delta::FromMilliseconds(5);
+  auto [alarm1, delegate1] = CreateAlarm();
+  auto [alarm2, delegate2] = CreateAlarm();
+
+  alarm1->Set(clock_.Now() - 2 * kAlarmTimeout);
+  alarm2->Set(clock_.Now() - kAlarmTimeout);
+
+  {
+    testing::InSequence s;
+    EXPECT_CALL(*delegate1, OnAlarm());
+    EXPECT_CALL(*delegate2, OnAlarm());
+  }
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(100));
+}
+
+TEST_F(QuicPollEventLoopTest, AlarmCancelled) {
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+
+  constexpr auto kAlarmTimeout = QuicTime::Delta::FromMilliseconds(5);
+  auto [alarm, delegate] = CreateAlarm();
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+
+  alarm->Set(clock_.Now() + kAlarmTimeout);
+  alarm->Cancel();
+  alarm->Set(clock_.Now() + 2 * kAlarmTimeout);
+  EXPECT_EQ(ComputePollTimeout(), kAlarmTimeout);
+
+  EXPECT_CALL(*delegate, OnAlarm());
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(100));
+  EXPECT_THAT(loop_.timeouts(), ElementsAre(10));
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+}
+
+TEST_F(QuicPollEventLoopTest, AlarmCancelsAnotherAlarm) {
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+
+  constexpr auto kAlarmTimeout = QuicTime::Delta::FromMilliseconds(5);
+  auto [alarm1_ptr, delegate1] = CreateAlarm();
+  auto [alarm2_ptr, delegate2] = CreateAlarm();
+
+  QuicAlarm& alarm1 = *alarm1_ptr;
+  QuicAlarm& alarm2 = *alarm2_ptr;
+  alarm1.Set(clock_.Now() - kAlarmTimeout);
+  alarm2.Set(clock_.Now() - kAlarmTimeout);
+
+  int alarms_called = 0;
+  // Since the order in which alarms are cancelled is not well-determined, make
+  // each one cancel another.
+  EXPECT_CALL(*delegate1, OnAlarm()).Times(AtMost(1)).WillOnce([&]() {
+    alarm2.Cancel();
+    ++alarms_called;
+  });
+  EXPECT_CALL(*delegate2, OnAlarm()).Times(AtMost(1)).WillOnce([&]() {
+    alarm1.Cancel();
+    ++alarms_called;
+  });
+  loop_.RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(100));
+  EXPECT_EQ(alarms_called, 1);
+  EXPECT_EQ(ComputePollTimeout(), kDefaultTimeout);
+}
+
+}  // namespace
+}  // namespace quic::test

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

@@ -294,9 +294,10 @@ bool QuicBufferedPacketStore::IngestPacketForTlsChloExtraction(
     const QuicConnectionId& connection_id, const ParsedQuicVersion& version,
     const QuicReceivedPacket& packet, std::vector<std::string>* out_alpns,
     std::string* out_sni, bool* out_resumption_attempted,
-    bool* out_early_data_attempted) {
+    bool* out_early_data_attempted, absl::optional<uint8_t>* tls_alert) {
   QUICHE_DCHECK_NE(out_alpns, nullptr);
   QUICHE_DCHECK_NE(out_sni, nullptr);
+  QUICHE_DCHECK_NE(tls_alert, nullptr);
   QUICHE_DCHECK_EQ(version.handshake_protocol, PROTOCOL_TLS1_3);
   auto it = undecryptable_packets_.find(connection_id);
   if (it == undecryptable_packets_.end()) {
@@ -306,6 +307,7 @@ bool QuicBufferedPacketStore::IngestPacketForTlsChloExtraction(
   }
   it->second.tls_chlo_extractor.IngestPacket(version, packet);
   if (!it->second.tls_chlo_extractor.HasParsedFullChlo()) {
+    *tls_alert = it->second.tls_chlo_extractor.tls_alert();
     return false;
   }
   const TlsChloExtractor& tls_chlo_extractor = it->second.tls_chlo_extractor;

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

@@ -119,13 +119,13 @@ class QUIC_NO_EXPORT QuicBufferedPacketStore {
   // |out_resumption_attempted| is populated if the CHLO has the
   // 'pre_shared_key' TLS extension. |out_early_data_attempted| is populated if
   // the CHLO has the 'early_data' TLS extension.
-  bool IngestPacketForTlsChloExtraction(const QuicConnectionId& connection_id,
-                                        const ParsedQuicVersion& version,
-                                        const QuicReceivedPacket& packet,
-                                        std::vector<std::string>* out_alpns,
-                                        std::string* out_sni,
-                                        bool* out_resumption_attempted,
-                                        bool* out_early_data_attempted);
+  // When this returns false, and an unrecoverable error happened due to a TLS
+  // alert, |*tls_alert| will be set to the alert value.
+  bool IngestPacketForTlsChloExtraction(
+      const QuicConnectionId& connection_id, const ParsedQuicVersion& version,
+      const QuicReceivedPacket& packet, std::vector<std::string>* out_alpns,
+      std::string* out_sni, bool* out_resumption_attempted,
+      bool* out_early_data_attempted, absl::optional<uint8_t>* tls_alert);
 
   // Returns the list of buffered packets for |connection_id| and removes them
   // from the store. Returns an empty list if no early arrived packets for this

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

@@ -468,6 +468,7 @@ TEST_F(QuicBufferedPacketStoreTest, IngestPacketForTlsChloExtraction) {
   bool resumption_attempted = false;
   bool early_data_attempted = false;
   QuicConfig config;
+  absl::optional<uint8_t> tls_alert;
 
   EXPECT_FALSE(store_.HasBufferedPackets(connection_id));
   store_.EnqueuePacket(connection_id, false, packet_, self_address_,
@@ -477,7 +478,7 @@ TEST_F(QuicBufferedPacketStoreTest, IngestPacketForTlsChloExtraction) {
   // The packet in 'packet_' is not a TLS CHLO packet.
   EXPECT_FALSE(store_.IngestPacketForTlsChloExtraction(
       connection_id, valid_version_, packet_, &alpns, &sni,
-      &resumption_attempted, &early_data_attempted));
+      &resumption_attempted, &early_data_attempted, &tls_alert));
 
   store_.DiscardPackets(connection_id);
 
@@ -498,10 +499,10 @@ TEST_F(QuicBufferedPacketStoreTest, IngestPacketForTlsChloExtraction) {
   EXPECT_TRUE(store_.HasBufferedPackets(connection_id));
   EXPECT_FALSE(store_.IngestPacketForTlsChloExtraction(
       connection_id, valid_version_, *packets[0], &alpns, &sni,
-      &resumption_attempted, &early_data_attempted));
+      &resumption_attempted, &early_data_attempted, &tls_alert));
   EXPECT_TRUE(store_.IngestPacketForTlsChloExtraction(
       connection_id, valid_version_, *packets[1], &alpns, &sni,
-      &resumption_attempted, &early_data_attempted));
+      &resumption_attempted, &early_data_attempted, &tls_alert));
 
   EXPECT_THAT(alpns, ElementsAre(AlpnForVersion(valid_version_)));
   EXPECT_EQ(sni, TestHostname());

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

@@ -8,6 +8,7 @@
 #include <sys/types.h>
 
 #include <algorithm>
+#include <cstdint>
 #include <iterator>
 #include <limits>
 #include <memory>
@@ -562,21 +563,23 @@ void QuicConnection::SetFromConfig(const QuicConfig& config) {
     if (config.HasClientSentConnectionOption(kNBHD, perspective_)) {
       blackhole_detection_disabled_ = true;
     }
-    if (config.HasClientSentConnectionOption(k2RTO, perspective_)) {
-      QUIC_CODE_COUNT(quic_2rto_blackhole_detection);
-      num_rtos_for_blackhole_detection_ = 2;
-    }
-    if (config.HasClientSentConnectionOption(k3RTO, perspective_)) {
-      QUIC_CODE_COUNT(quic_3rto_blackhole_detection);
-      num_rtos_for_blackhole_detection_ = 3;
-    }
-    if (config.HasClientSentConnectionOption(k4RTO, perspective_)) {
-      QUIC_CODE_COUNT(quic_4rto_blackhole_detection);
-      num_rtos_for_blackhole_detection_ = 4;
-    }
-    if (config.HasClientSentConnectionOption(k6RTO, perspective_)) {
-      QUIC_CODE_COUNT(quic_6rto_blackhole_detection);
-      num_rtos_for_blackhole_detection_ = 6;
+    if (!sent_packet_manager_.remove_blackhole_detection_experiments()) {
+      if (config.HasClientSentConnectionOption(k2RTO, perspective_)) {
+        QUIC_CODE_COUNT(quic_2rto_blackhole_detection);
+        num_rtos_for_blackhole_detection_ = 2;
+      }
+      if (config.HasClientSentConnectionOption(k3RTO, perspective_)) {
+        QUIC_CODE_COUNT(quic_3rto_blackhole_detection);
+        num_rtos_for_blackhole_detection_ = 3;
+      }
+      if (config.HasClientSentConnectionOption(k4RTO, perspective_)) {
+        QUIC_CODE_COUNT(quic_4rto_blackhole_detection);
+        num_rtos_for_blackhole_detection_ = 4;
+      }
+      if (config.HasClientSentConnectionOption(k6RTO, perspective_)) {
+        QUIC_CODE_COUNT(quic_6rto_blackhole_detection);
+        num_rtos_for_blackhole_detection_ = 6;
+      }
     }
   }
 
@@ -3655,10 +3658,24 @@ bool QuicConnection::WritePacket(SerializedPacket* packet) {
       sent_packet_manager_.GetLeastPacketAwaitedByPeer(encryption_level_),
       sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
 
-  stats_.bytes_sent += result.bytes_written;
+  stats_.bytes_sent += encrypted_length;
   ++stats_.packets_sent;
+
+  QuicByteCount bytes_not_retransmitted =
+      packet->bytes_not_retransmitted.value_or(0);
   if (packet->transmission_type != NOT_RETRANSMISSION) {
-    stats_.bytes_retransmitted += result.bytes_written;
+    if (static_cast<uint64_t>(encrypted_length) < bytes_not_retransmitted) {
+      QUIC_BUG(quic_packet_bytes_written_lt_bytes_not_retransmitted)
+          << "Total bytes written to the packet should be larger than the "
+             "bytes in not-retransmitted frames. Bytes written: "
+          << encrypted_length
+          << ", bytes not retransmitted: " << bytes_not_retransmitted;
+    } else {
+      // bytes_retransmitted includes packet's headers and encryption
+      // overhead.
+      stats_.bytes_retransmitted +=
+          (encrypted_length - bytes_not_retransmitted);
+    }
     ++stats_.packets_retransmitted;
   }
 
@@ -4827,6 +4844,14 @@ QuicConnection::ScopedPacketFlusher::~ScopedPacketFlusher() {
       connection_->FlushCoalescedPacket();
     }
     connection_->FlushPackets();
+    if (GetQuicReloadableFlag(
+            quic_packet_flusher_check_connected_after_flush_packets)) {
+      QUIC_RELOADABLE_FLAG_COUNT(
+          quic_packet_flusher_check_connected_after_flush_packets);
+      if (!connection_->connected()) {
+        return;
+      }
+    }
     if (!handshake_packet_sent_ && connection_->handshake_packet_sent_) {
       // This would cause INITIAL key to be dropped. Drop keys here to avoid
       // missing the write keys in the middle of writing.
@@ -6373,11 +6398,12 @@ bool QuicConnection::SendNewConnectionId(
   return connected_;
 }
 
-void QuicConnection::OnNewConnectionIdIssued(
+bool QuicConnection::MaybeReserveConnectionId(
     const QuicConnectionId& connection_id) {
   if (perspective_ == Perspective::IS_SERVER) {
-    visitor_->OnServerConnectionIdIssued(connection_id);
+    return visitor_->MaybeReserveConnectionId(connection_id);
   }
+  return true;
 }
 
 void QuicConnection::OnSelfIssuedConnectionIdRetired(
@@ -6424,11 +6450,35 @@ QuicTime QuicConnection::GetNetworkBlackholeDeadline() const {
     return QuicTime::Zero();
   }
   QUICHE_DCHECK_LT(0u, num_rtos_for_blackhole_detection_);
+  if (sent_packet_manager_.remove_blackhole_detection_experiments()) {
+    QUIC_RELOADABLE_FLAG_COUNT(quic_remove_blackhole_detection_experiments);
+    const QuicTime::Delta blackhole_delay =
+        sent_packet_manager_.GetNetworkBlackholeDelay(
+            num_rtos_for_blackhole_detection_);
+    if (!ShouldDetectPathDegrading()) {
+      return clock_->ApproximateNow() + blackhole_delay;
+    }
+    return clock_->ApproximateNow() +
+           CalculateNetworkBlackholeDelay(
+               blackhole_delay, sent_packet_manager_.GetPathDegradingDelay(),
+               sent_packet_manager_.GetPtoDelay());
+  }
   return clock_->ApproximateNow() +
          sent_packet_manager_.GetNetworkBlackholeDelay(
              num_rtos_for_blackhole_detection_);
 }
 
+// static
+QuicTime::Delta QuicConnection::CalculateNetworkBlackholeDelay(
+    QuicTime::Delta blackhole_delay, QuicTime::Delta path_degrading_delay,
+    QuicTime::Delta pto_delay) {
+  const QuicTime::Delta min_delay = path_degrading_delay + pto_delay * 2;
+  if (blackhole_delay < min_delay) {
+    QUIC_CODE_COUNT(quic_extending_short_blackhole_delay);
+  }
+  return std::max(min_delay, blackhole_delay);
+}
+
 bool QuicConnection::ShouldDetectBlackhole() const {
   if (!connected_ || blackhole_detection_disabled_) {
     return false;

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

@@ -164,8 +164,9 @@ class QUIC_EXPORT_PRIVATE QuicConnectionVisitorInterface {
   // Called to send a RETIRE_CONNECTION_ID frame.
   virtual void SendRetireConnectionId(uint64_t sequence_number) = 0;
 
-  // Called when server starts to use a server issued connection ID.
-  virtual void OnServerConnectionIdIssued(
+  // Called when server starts to use a server issued connection ID. Returns
+  // true if this connection ID hasn't been used by another connection.
+  virtual bool MaybeReserveConnectionId(
       const QuicConnectionId& server_connection_id) = 0;
 
   // Called when server stops to use a server issued connection ID.
@@ -718,7 +719,7 @@ class QUIC_EXPORT_PRIVATE QuicConnection
   // QuicConnectionIdManagerVisitorInterface
   void OnPeerIssuedConnectionIdRetired() override;
   bool SendNewConnectionId(const QuicNewConnectionIdFrame& frame) override;
-  void OnNewConnectionIdIssued(const QuicConnectionId& connection_id) override;
+  bool MaybeReserveConnectionId(const QuicConnectionId& connection_id) override;
   void OnSelfIssuedConnectionIdRetired(
       const QuicConnectionId& connection_id) override;
 
@@ -1230,6 +1231,11 @@ class QUIC_EXPORT_PRIVATE QuicConnection
     return quic_bug_10511_43_error_detail_;
   }
 
+  // Ensures the network blackhole delay is longer than path degrading delay.
+  static QuicTime::Delta CalculateNetworkBlackholeDelay(
+      QuicTime::Delta blackhole_delay, QuicTime::Delta path_degrading_delay,
+      QuicTime::Delta pto_delay);
+
  protected:
   // Calls cancel() on all the alarms owned by this connection.
   void CancelAllAlarms();

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

@@ -10,6 +10,7 @@
 #include "quiche/quic/core/quic_connection_id.h"
 #include "quiche/quic/core/quic_error_codes.h"
 #include "quiche/quic/core/quic_utils.h"
+#include "quiche/quic/platform/api/quic_flag_utils.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 
 namespace quic {
@@ -298,14 +299,28 @@ QuicConnectionId QuicSelfIssuedConnectionIdManager::GenerateNewConnectionId(
   return QuicUtils::CreateReplacementConnectionId(old_connection_id);
 }
 
-QuicNewConnectionIdFrame
-QuicSelfIssuedConnectionIdManager::IssueNewConnectionId() {
+absl::optional<QuicNewConnectionIdFrame>
+QuicSelfIssuedConnectionIdManager::MaybeIssueNewConnectionId() {
+  const bool check_cid_collision_when_issue_new_cid =
+      GetQuicReloadableFlag(quic_check_cid_collision_when_issue_new_cid);
+  QuicConnectionId new_cid = GenerateNewConnectionId(last_connection_id_);
+  if (check_cid_collision_when_issue_new_cid) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_check_cid_collision_when_issue_new_cid, 1,
+                                 2);
+    if (!visitor_->MaybeReserveConnectionId(new_cid)) {
+      QUIC_RELOADABLE_FLAG_COUNT_N(quic_check_cid_collision_when_issue_new_cid,
+                                   2, 2);
+      return {};
+    }
+  }
   QuicNewConnectionIdFrame frame;
-  frame.connection_id = GenerateNewConnectionId(last_connection_id_);
+  frame.connection_id = new_cid;
   frame.sequence_number = next_connection_id_sequence_number_++;
   frame.stateless_reset_token =
       QuicUtils::GenerateStatelessResetToken(frame.connection_id);
-  visitor_->OnNewConnectionIdIssued(frame.connection_id);
+  if (!check_cid_collision_when_issue_new_cid) {
+    visitor_->MaybeReserveConnectionId(frame.connection_id);
+  }
   active_connection_ids_.emplace_back(frame.connection_id,
                                       frame.sequence_number);
   frame.retire_prior_to = active_connection_ids_.front().second;
@@ -313,10 +328,10 @@ QuicSelfIssuedConnectionIdManager::IssueNewConnectionId() {
   return frame;
 }
 
-QuicNewConnectionIdFrame
-QuicSelfIssuedConnectionIdManager::IssueNewConnectionIdForPreferredAddress() {
-  QuicNewConnectionIdFrame frame = IssueNewConnectionId();
-  QUICHE_DCHECK_EQ(frame.sequence_number, 1u);
+absl::optional<QuicNewConnectionIdFrame> QuicSelfIssuedConnectionIdManager::
+    MaybeIssueNewConnectionIdForPreferredAddress() {
+  absl::optional<QuicNewConnectionIdFrame> frame = MaybeIssueNewConnectionId();
+  QUICHE_DCHECK(!frame.has_value() || (frame->sequence_number == 1u));
   return frame;
 }
 
@@ -406,8 +421,12 @@ void QuicSelfIssuedConnectionIdManager::RetireConnectionId() {
 
 void QuicSelfIssuedConnectionIdManager::MaybeSendNewConnectionIds() {
   while (active_connection_ids_.size() < active_connection_id_limit_) {
-    QuicNewConnectionIdFrame frame = IssueNewConnectionId();
-    if (!visitor_->SendNewConnectionId(frame)) {
+    absl::optional<QuicNewConnectionIdFrame> frame =
+        MaybeIssueNewConnectionId();
+    if (!frame.has_value()) {
+      break;
+    }
+    if (!visitor_->SendNewConnectionId(*frame)) {
       break;
     }
   }