@fails-components/webtransport 0.0.1 → 0.0.2

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

@@ -47,7 +47,7 @@ class QUIC_EXPORT_PRIVATE QuicConnectionIdManagerVisitorInterface {
   virtual ~QuicConnectionIdManagerVisitorInterface() = default;
   virtual void OnPeerIssuedConnectionIdRetired() = 0;
   virtual bool SendNewConnectionId(const QuicNewConnectionIdFrame& frame) = 0;
-  virtual void OnNewConnectionIdIssued(
+  virtual bool MaybeReserveConnectionId(
       const QuicConnectionId& connection_id) = 0;
   virtual void OnSelfIssuedConnectionIdRetired(
       const QuicConnectionId& connection_id) = 0;
@@ -130,7 +130,8 @@ class QUIC_EXPORT_PRIVATE QuicSelfIssuedConnectionIdManager {
 
   virtual ~QuicSelfIssuedConnectionIdManager();
 
-  QuicNewConnectionIdFrame IssueNewConnectionIdForPreferredAddress();
+  absl::optional<QuicNewConnectionIdFrame>
+  MaybeIssueNewConnectionIdForPreferredAddress();
 
   QuicErrorCode OnRetireConnectionIdFrame(
       const QuicRetireConnectionIdFrame& frame, QuicTime::Delta pto_delay,
@@ -164,7 +165,8 @@ class QUIC_EXPORT_PRIVATE QuicSelfIssuedConnectionIdManager {
  private:
   friend class test::QuicConnectionIdManagerPeer;
 
-  QuicNewConnectionIdFrame IssueNewConnectionId();
+  // Issue a new connection ID. Can return nullopt.
+  absl::optional<QuicNewConnectionIdFrame> MaybeIssueNewConnectionId();
 
   // This should be set to the min of:
   // (1) # of active connection IDs that peer can maintain.

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

@@ -64,8 +64,10 @@ class TestPeerIssuedConnectionIdManagerVisitor
   bool SendNewConnectionId(const QuicNewConnectionIdFrame& /*frame*/) override {
     return false;
   }
-  void OnNewConnectionIdIssued(
-      const QuicConnectionId& /*connection_id*/) override {}
+  bool MaybeReserveConnectionId(const QuicConnectionId&) override {
+    return false;
+  }
+
   void OnSelfIssuedConnectionIdRetired(
       const QuicConnectionId& /*connection_id*/) override {}
 
@@ -522,7 +524,7 @@ class TestSelfIssuedConnectionIdManagerVisitor
 
   MOCK_METHOD(bool, SendNewConnectionId,
               (const QuicNewConnectionIdFrame& frame), (override));
-  MOCK_METHOD(void, OnNewConnectionIdIssued,
+  MOCK_METHOD(bool, MaybeReserveConnectionId,
               (const QuicConnectionId& connection_id), (override));
   MOCK_METHOD(void, OnSelfIssuedConnectionIdRetired,
               (const QuicConnectionId& connection_id), (override));
@@ -568,7 +570,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
   QuicConnectionId cid5 = cid_manager_.GenerateNewConnectionId(cid4);
 
   // Sends CID #1 to peer.
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid1));
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid1))
+      .WillOnce(Return(true));
   EXPECT_CALL(cid_manager_visitor_,
               SendNewConnectionId(ExpectedNewConnectionIdFrame(cid1, 1u, 0u)))
       .WillOnce(Return(true));
@@ -578,7 +581,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
     // Peer retires CID #0;
     // Sends CID #2 and asks peer to retire CIDs prior to #1.
     // Outcome: (#1, #2) are active.
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid2));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid2))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_,
                 SendNewConnectionId(ExpectedNewConnectionIdFrame(cid2, 2u, 1u)))
         .WillOnce(Return(true));
@@ -593,7 +597,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
     // Peer retires CID #1;
     // Sends CID #3 and asks peer to retire CIDs prior to #2.
     // Outcome: (#2, #3) are active.
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid3));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid3))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_,
                 SendNewConnectionId(ExpectedNewConnectionIdFrame(cid3, 3u, 2u)))
         .WillOnce(Return(true));
@@ -608,7 +613,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
     // Peer retires CID #2;
     // Sends CID #4 and asks peer to retire CIDs prior to #3.
     // Outcome: (#3, #4) are active.
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid4));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid4))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_,
                 SendNewConnectionId(ExpectedNewConnectionIdFrame(cid4, 4u, 3u)))
         .WillOnce(Return(true));
@@ -623,7 +629,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
     // Peer retires CID #3;
     // Sends CID #5 and asks peer to retire CIDs prior to #4.
     // Outcome: (#4, #5) are active.
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid5));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid5))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_,
                 SendNewConnectionId(ExpectedNewConnectionIdFrame(cid5, 5u, 4u)))
         .WillOnce(Return(true));
@@ -644,7 +651,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
   QuicConnectionId cid4 = cid_manager_.GenerateNewConnectionId(cid3);
 
   // Sends CID #1 to peer.
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid1));
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid1))
+      .WillOnce(Return(true));
   EXPECT_CALL(cid_manager_visitor_,
               SendNewConnectionId(ExpectedNewConnectionIdFrame(cid1, 1u, 0u)))
       .WillOnce(Return(true));
@@ -654,7 +662,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
     // Peer retires CID #1;
     // Sends CID #2 and asks peer to retire CIDs prior to #0.
     // Outcome: (#0, #2) are active.
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid2));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid2))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_,
                 SendNewConnectionId(ExpectedNewConnectionIdFrame(cid2, 2u, 0u)))
         .WillOnce(Return(true));
@@ -678,7 +687,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
     // Peer retires CID #0;
     // Sends CID #3 and asks peer to retire CIDs prior to #2.
     // Outcome: (#2, #3) are active.
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid3));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid3))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_,
                 SendNewConnectionId(ExpectedNewConnectionIdFrame(cid3, 3u, 2u)))
         .WillOnce(Return(true));
@@ -693,7 +703,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
     // Peer retires CID #3;
     // Sends CID #4 and asks peer to retire CIDs prior to #2.
     // Outcome: (#2, #4) are active.
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid4));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid4))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_,
                 SendNewConnectionId(ExpectedNewConnectionIdFrame(cid4, 4u, 2u)))
         .WillOnce(Return(true));
@@ -720,7 +731,9 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
   QuicConnectionId cid1 = cid_manager_.GenerateNewConnectionId(cid0);
   QuicConnectionId cid2 = cid_manager_.GenerateNewConnectionId(cid1);
   QuicConnectionId cid3 = cid_manager_.GenerateNewConnectionId(cid2);
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(_)).Times(3);
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(_))
+      .Times(3)
+      .WillRepeatedly(Return(true));
   EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_))
       .Times(3)
       .WillRepeatedly(Return(true));
@@ -777,7 +790,9 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
   QuicConnectionId cid1 = cid_manager_.GenerateNewConnectionId(cid0);
   QuicConnectionId cid2 = cid_manager_.GenerateNewConnectionId(cid1);
   QuicConnectionId cid3 = cid_manager_.GenerateNewConnectionId(cid2);
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(_)).Times(3);
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(_))
+      .Times(3)
+      .WillRepeatedly(Return(true));
   EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_))
       .Times(3)
       .WillRepeatedly(Return(true));
@@ -834,7 +849,9 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
   QuicConnectionId cid2 = cid_manager_.GenerateNewConnectionId(cid1);
   QuicConnectionId cid3 = cid_manager_.GenerateNewConnectionId(cid2);
   QuicConnectionId cid;
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(_)).Times(3);
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(_))
+      .Times(3)
+      .WillRepeatedly(Return(true));
   EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_))
       .Times(3)
       .WillRepeatedly(Return(true));
@@ -893,7 +910,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
   QuicConnectionId cid1 = cid_manager_.GenerateNewConnectionId(cid0);
 
   // CID #1 is sent to peer.
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(_)).Times(1);
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Return(true));
   EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_))
       .WillOnce(Return(true));
   cid_manager_.MaybeSendNewConnectionIds();
@@ -909,7 +927,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
 TEST_F(QuicSelfIssuedConnectionIdManagerTest,
        ErrorWhenTooManyConnectionIdWaitingToBeRetired) {
   // CID #0 & #1 are issued.
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(_));
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Return(true));
   EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_))
       .WillOnce(Return(true));
   cid_manager_.MaybeSendNewConnectionIds();
@@ -918,7 +937,8 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
   QuicConnectionId last_connection_id =
       cid_manager_.GenerateNewConnectionId(initial_connection_id_);
   for (int i = 0; i < 8; ++i) {
-    EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(_));
+    EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(_))
+        .WillOnce(Return(true));
     EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_));
     QuicRetireConnectionIdFrame retire_cid_frame;
     retire_cid_frame.sequence_number = i;
@@ -937,17 +957,60 @@ TEST_F(QuicSelfIssuedConnectionIdManagerTest,
               IsError(QUIC_TOO_MANY_CONNECTION_ID_WAITING_TO_RETIRE));
 }
 
+TEST_F(QuicSelfIssuedConnectionIdManagerTest, CannotIssueNewCidDueToVisitor) {
+  QuicConnectionId cid0 = initial_connection_id_;
+  QuicConnectionId cid1 = cid_manager_.GenerateNewConnectionId(cid0);
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid1))
+      .WillOnce(Return(false));
+  if (GetQuicReloadableFlag(quic_check_cid_collision_when_issue_new_cid)) {
+    EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_)).Times(0);
+  } else {
+    EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_)).Times(1);
+  }
+  cid_manager_.MaybeSendNewConnectionIds();
+}
+
+TEST_F(QuicSelfIssuedConnectionIdManagerTest,
+       CannotIssueNewCidUponRetireConnectionIdDueToVisitor) {
+  QuicConnectionId cid0 = initial_connection_id_;
+  QuicConnectionId cid1 = cid_manager_.GenerateNewConnectionId(cid0);
+  QuicConnectionId cid2 = cid_manager_.GenerateNewConnectionId(cid1);
+  // CID #0 & #1 are issued.
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid1))
+      .WillOnce(Return(true));
+  EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_))
+      .WillOnce(Return(true));
+  cid_manager_.MaybeSendNewConnectionIds();
+
+  // CID #2 is not issued.
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid2))
+      .WillOnce(Return(false));
+  if (GetQuicReloadableFlag(quic_check_cid_collision_when_issue_new_cid)) {
+    EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_)).Times(0);
+  } else {
+    EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_)).Times(1);
+  }
+  QuicRetireConnectionIdFrame retire_cid_frame;
+  retire_cid_frame.sequence_number = 1;
+  ASSERT_THAT(cid_manager_.OnRetireConnectionIdFrame(
+                  retire_cid_frame, pto_delay_, &error_details_),
+              IsQuicNoError());
+}
+
 TEST_F(QuicSelfIssuedConnectionIdManagerTest,
        DoNotIssueConnectionIdVoluntarilyIfOneHasIssuedForPerferredAddress) {
   QuicConnectionId cid0 = initial_connection_id_;
   QuicConnectionId cid1 = cid_manager_.GenerateNewConnectionId(cid0);
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(cid1));
-  ASSERT_THAT(cid_manager_.IssueNewConnectionIdForPreferredAddress(),
-              ExpectedNewConnectionIdFrame(cid1, 1u, 0u));
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(cid1))
+      .WillOnce(Return(true));
+  absl::optional<QuicNewConnectionIdFrame> new_cid_frame =
+      cid_manager_.MaybeIssueNewConnectionIdForPreferredAddress();
+  ASSERT_TRUE(new_cid_frame.has_value());
+  ASSERT_THAT(*new_cid_frame, ExpectedNewConnectionIdFrame(cid1, 1u, 0u));
   EXPECT_THAT(cid_manager_.GetUnretiredConnectionIds(),
               ElementsAre(cid0, cid1));
 
-  EXPECT_CALL(cid_manager_visitor_, OnNewConnectionIdIssued(_)).Times(0);
+  EXPECT_CALL(cid_manager_visitor_, MaybeReserveConnectionId(_)).Times(0);
   EXPECT_CALL(cid_manager_visitor_, SendNewConnectionId(_)).Times(0);
   cid_manager_.MaybeSendNewConnectionIds();
 }

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

@@ -240,10 +240,19 @@ class TestConnection : public QuicConnection {
                                          absl::string_view data,
                                          QuicStreamOffset offset,
                                          StreamSendingState state) {
+    return SaveAndSendStreamData(id, data, offset, state, NOT_RETRANSMISSION);
+  }
+
+  QuicConsumedData SaveAndSendStreamData(QuicStreamId id,
+                                         absl::string_view data,
+                                         QuicStreamOffset offset,
+                                         StreamSendingState state,
+                                         TransmissionType transmission_type) {
     ScopedPacketFlusher flusher(this);
     producer_.SaveStreamData(id, data);
     if (notifier_ != nullptr) {
-      return notifier_->WriteOrBufferData(id, data.length(), state);
+      return notifier_->WriteOrBufferData(id, data.length(), state,
+                                          transmission_type);
     }
     return QuicConnection::SendStreamData(id, data.length(), offset, state);
   }
@@ -1857,9 +1866,11 @@ TEST_P(QuicConnectionTest, PeerIpAddressChangeAtServerWithMissingConnectionId) {
   QuicConnectionPeer::SetAddressValidated(&connection_);
 
   // Sends new server CID to client.
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
-      .WillOnce(
-          Invoke([&](const QuicConnectionId& cid) { server_cid1 = cid; }));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Invoke([&](const QuicConnectionId& cid) {
+        server_cid1 = cid;
+        return true;
+      }));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   connection_.OnHandshakeComplete();
 
@@ -2048,8 +2059,11 @@ TEST_P(QuicConnectionTest, ConnectionMigrationWithPendingPaddingBytes) {
 
   // Sends new server CID to client.
   QuicConnectionId new_cid;
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
-      .WillOnce(Invoke([&](const QuicConnectionId& cid) { new_cid = cid; }));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Invoke([&](const QuicConnectionId& cid) {
+        new_cid = cid;
+        return true;
+      }));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   // Discard INITIAL key.
   connection_.RemoveEncrypter(ENCRYPTION_INITIAL);
@@ -2102,8 +2116,11 @@ TEST_P(QuicConnectionTest,
 
   // Sends new server CID to client.
   QuicConnectionId new_cid;
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
-      .WillOnce(Invoke([&](const QuicConnectionId& cid) { new_cid = cid; }));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Invoke([&](const QuicConnectionId& cid) {
+        new_cid = cid;
+        return true;
+      }));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   // Discard INITIAL key.
   connection_.RemoveEncrypter(ENCRYPTION_INITIAL);
@@ -2167,9 +2184,11 @@ TEST_P(QuicConnectionTest, ReversePathValidationFailureAtServer) {
   QuicConnectionId server_cid0 = connection_.connection_id();
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
-      .WillOnce(
-          Invoke([&](const QuicConnectionId& cid) { server_cid1 = cid; }));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Invoke([&](const QuicConnectionId& cid) {
+        server_cid1 = cid;
+        return true;
+      }));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   connection_.OnHandshakeComplete();
   // Receives new client CID from client.
@@ -3545,6 +3564,86 @@ TEST_P(QuicConnectionTest, RecordSentTimeBeforePacketSent) {
       << ".  Actual time = " << actual_recorded_send_time.ToDebuggingValue();
 }
 
+TEST_P(QuicConnectionTest, ConnectionStatsRetransmission_WithRetransmissions) {
+  // Send two stream frames in 1 packet by queueing them.
+  connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
+
+  {
+    QuicConnection::ScopedPacketFlusher flusher(&connection_);
+    connection_.SaveAndSendStreamData(
+        GetNthClientInitiatedStreamId(1, connection_.transport_version()),
+        "helloworld", 0, NO_FIN, PTO_RETRANSMISSION);
+    connection_.SaveAndSendStreamData(
+        GetNthClientInitiatedStreamId(2, connection_.transport_version()),
+        "helloworld", 0, NO_FIN, LOSS_RETRANSMISSION);
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  }
+
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+  EXPECT_FALSE(connection_.HasQueuedData());
+
+  EXPECT_EQ(2u, writer_->frame_count());
+  for (auto& frame : writer_->stream_frames()) {
+    EXPECT_EQ(frame->data_length, 10u);
+  }
+
+  ASSERT_EQ(connection_.GetStats().packets_retransmitted, 1u);
+  ASSERT_GE(connection_.GetStats().bytes_retransmitted, 20u);
+}
+
+TEST_P(QuicConnectionTest, ConnectionStatsRetransmission_WithMixedFrames) {
+  // Send two stream frames in 1 packet by queueing them.
+  connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
+
+  {
+    QuicConnection::ScopedPacketFlusher flusher(&connection_);
+    // First frame is retransmission. Second is NOT_RETRANSMISSION but the
+    // packet retains the PTO_RETRANSMISSION type.
+    connection_.SaveAndSendStreamData(
+        GetNthClientInitiatedStreamId(1, connection_.transport_version()),
+        "helloworld", 0, NO_FIN, PTO_RETRANSMISSION);
+    connection_.SaveAndSendStreamData(
+        GetNthClientInitiatedStreamId(2, connection_.transport_version()),
+        "helloworld", 0, NO_FIN, NOT_RETRANSMISSION);
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  }
+
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+  EXPECT_FALSE(connection_.HasQueuedData());
+
+  EXPECT_EQ(2u, writer_->frame_count());
+  for (auto& frame : writer_->stream_frames()) {
+    EXPECT_EQ(frame->data_length, 10u);
+  }
+
+  ASSERT_EQ(connection_.GetStats().packets_retransmitted, 1u);
+  ASSERT_GE(connection_.GetStats().bytes_retransmitted, 10u);
+}
+
+TEST_P(QuicConnectionTest, ConnectionStatsRetransmission_NoRetransmission) {
+  // Send two stream frames in 1 packet by queueing them.
+  connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
+
+  {
+    QuicConnection::ScopedPacketFlusher flusher(&connection_);
+    // Both frames are NOT_RETRANSMISSION
+    connection_.SaveAndSendStreamData(
+        GetNthClientInitiatedStreamId(1, connection_.transport_version()),
+        "helloworld", 0, NO_FIN, NOT_RETRANSMISSION);
+    connection_.SaveAndSendStreamData(
+        GetNthClientInitiatedStreamId(2, connection_.transport_version()),
+        "helloworld", 0, NO_FIN, NOT_RETRANSMISSION);
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  }
+
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+  EXPECT_FALSE(connection_.HasQueuedData());
+
+  EXPECT_EQ(2u, writer_->frame_count());
+  ASSERT_EQ(connection_.GetStats().packets_retransmitted, 0u);
+  ASSERT_EQ(connection_.GetStats().bytes_retransmitted, 0u);
+}
+
 TEST_P(QuicConnectionTest, FramePacking) {
   // Send two stream frames in 1 packet by queueing them.
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
@@ -9782,7 +9881,10 @@ TEST_P(QuicConnectionTest, FailToCoalescePacket) {
   use_tagging_decrypter();
 
   auto test_body = [&] {
-    EXPECT_CALL(visitor_, OnHandshakePacketSent());
+    if (!GetQuicReloadableFlag(
+            quic_packet_flusher_check_connected_after_flush_packets)) {
+      EXPECT_CALL(visitor_, OnHandshakePacketSent());
+    }
 
     EXPECT_CALL(visitor_,
                 OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF))
@@ -10554,7 +10656,8 @@ TEST_P(QuicConnectionTest, ClientOnlyBlackholeDetectionServer) {
 }
 
 TEST_P(QuicConnectionTest, 2RtoBlackholeDetection) {
-  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2)) {
+  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2) ||
+      GetQuicReloadableFlag(quic_remove_blackhole_detection_experiments)) {
     return;
   }
   QuicConfig config;
@@ -10581,7 +10684,8 @@ TEST_P(QuicConnectionTest, 2RtoBlackholeDetection) {
 }
 
 TEST_P(QuicConnectionTest, 3RtoBlackholeDetection) {
-  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2)) {
+  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2) ||
+      GetQuicReloadableFlag(quic_remove_blackhole_detection_experiments)) {
     return;
   }
   QuicConfig config;
@@ -10608,7 +10712,8 @@ TEST_P(QuicConnectionTest, 3RtoBlackholeDetection) {
 }
 
 TEST_P(QuicConnectionTest, 4RtoBlackholeDetection) {
-  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2)) {
+  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2) ||
+      GetQuicReloadableFlag(quic_remove_blackhole_detection_experiments)) {
     return;
   }
   QuicConfig config;
@@ -10635,7 +10740,8 @@ TEST_P(QuicConnectionTest, 4RtoBlackholeDetection) {
 }
 
 TEST_P(QuicConnectionTest, 6RtoBlackholeDetection) {
-  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2)) {
+  if (!GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2) ||
+      GetQuicReloadableFlag(quic_remove_blackhole_detection_experiments)) {
     return;
   }
   QuicConfig config;
@@ -13219,9 +13325,11 @@ TEST_P(QuicConnectionTest, PathChallengeBeforePeerIpAddressChangeAtServer) {
   QuicConnectionId client_cid1 = TestConnectionId(2);
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
-      .WillOnce(
-          Invoke([&](const QuicConnectionId& cid) { server_cid1 = cid; }));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Invoke([&](const QuicConnectionId& cid) {
+        server_cid1 = cid;
+        return true;
+      }));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   connection_.MaybeSendConnectionIdToClient();
   // Receives new client CID from client.
@@ -13365,9 +13473,11 @@ TEST_P(QuicConnectionTest,
   QuicConnectionId server_cid0 = connection_.connection_id();
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
-      .WillOnce(
-          Invoke([&](const QuicConnectionId& cid) { server_cid1 = cid; }));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Invoke([&](const QuicConnectionId& cid) {
+        server_cid1 = cid;
+        return true;
+      }));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   connection_.MaybeSendConnectionIdToClient();
   auto* packet_creator = QuicConnectionPeer::GetPacketCreator(&connection_);
@@ -13484,9 +13594,11 @@ TEST_P(QuicConnectionTest, NoNonProbingFrameOnAlternativePath) {
   QuicConnectionId client_cid1 = TestConnectionId(2);
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
-      .WillOnce(
-          Invoke([&](const QuicConnectionId& cid) { server_cid1 = cid; }));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+      .WillOnce(Invoke([&](const QuicConnectionId& cid) {
+        server_cid1 = cid;
+        return true;
+      }));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   connection_.MaybeSendConnectionIdToClient();
   // Receives new client CID from client.
@@ -13586,6 +13698,27 @@ TEST_P(QuicConnectionTest, NoNonProbingFrameOnAlternativePath) {
   }
 }
 
+TEST_P(QuicConnectionTest, DoNotIssueNewCidIfVisitorSaysNo) {
+  set_perspective(Perspective::IS_SERVER);
+  if (!connection_.connection_migration_use_new_cid()) {
+    return;
+  }
+
+  connection_.CreateConnectionIdManager();
+
+  QuicConnectionId server_cid0 = connection_.connection_id();
+  QuicConnectionId client_cid1 = TestConnectionId(2);
+  QuicConnectionId server_cid1;
+  // Sends new server CID to client.
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_)).WillOnce(Return(false));
+  if (GetQuicReloadableFlag(quic_check_cid_collision_when_issue_new_cid)) {
+    EXPECT_CALL(visitor_, SendNewConnectionId(_)).Times(0);
+  } else {
+    EXPECT_CALL(visitor_, SendNewConnectionId(_)).Times(1);
+  }
+  connection_.MaybeSendConnectionIdToClient();
+}
+
 TEST_P(QuicConnectionTest,
        ProbedOnAnotherPathAfterPeerIpAddressChangeAtServer) {
   PathProbeTestInit(Perspective::IS_SERVER);
@@ -14121,7 +14254,7 @@ TEST_P(QuicConnectionTest, RetireConnectionIdFrameResultsInError) {
   set_perspective(Perspective::IS_SERVER);
   connection_.CreateConnectionIdManager();
 
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_));
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   connection_.MaybeSendConnectionIdToClient();
 
@@ -14154,7 +14287,9 @@ TEST_P(QuicConnectionTest,
   QuicRetireConnectionIdFrame frame;
   frame.sequence_number = 0u;
   if (connection_.connection_migration_use_new_cid()) {
-    EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_)).Times(2);
+    EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
+        .Times(2)
+        .WillRepeatedly(Return(true));
     EXPECT_CALL(visitor_, SendNewConnectionId(_)).Times(2);
   }
   EXPECT_TRUE(connection_.OnRetireConnectionIdFrame(frame));
@@ -14174,8 +14309,9 @@ TEST_P(QuicConnectionTest, ServerRetireSelfIssuedConnectionId) {
   set_perspective(Perspective::IS_SERVER);
   connection_.CreateConnectionIdManager();
   QuicConnectionId recorded_cid;
-  auto cid_recorder = [&recorded_cid](const QuicConnectionId& cid) {
+  auto cid_recorder = [&recorded_cid](const QuicConnectionId& cid) -> bool {
     recorded_cid = cid;
+    return true;
   };
   QuicConnectionId cid0 = connection_id_;
   QuicConnectionId cid1;
@@ -14184,7 +14320,7 @@ TEST_P(QuicConnectionTest, ServerRetireSelfIssuedConnectionId) {
   EXPECT_EQ(connection_.GetOneActiveServerConnectionId(), cid0);
 
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
       .WillOnce(Invoke(cid_recorder));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   connection_.MaybeSendConnectionIdToClient();
@@ -14215,7 +14351,7 @@ TEST_P(QuicConnectionTest, ServerRetireSelfIssuedConnectionId) {
 
   // Packet2 with RetireConnectionId frame trigers sending NewConnectionId
   // immediately.
-  EXPECT_CALL(visitor_, OnServerConnectionIdIssued(_))
+  EXPECT_CALL(visitor_, MaybeReserveConnectionId(_))
       .WillOnce(Invoke(cid_recorder));
   EXPECT_CALL(visitor_, SendNewConnectionId(_));
   peer_creator_.SetServerConnectionId(cid1);
@@ -15316,6 +15452,26 @@ TEST_P(QuicConnectionTest, EarliestSentTimeNotInitializedWhenPtoFires) {
   EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
 }
 
+TEST_P(QuicConnectionTest, CalculateNetworkBlackholeDelay) {
+  if (!IsDefaultTestConfiguration()) {
+    return;
+  }
+
+  const QuicTime::Delta kOneSec = QuicTime::Delta::FromSeconds(1);
+  const QuicTime::Delta kTwoSec = QuicTime::Delta::FromSeconds(2);
+  const QuicTime::Delta kFourSec = QuicTime::Delta::FromSeconds(4);
+
+  // Normal case: blackhole_delay longer than path_degrading_delay +
+  // 2*pto_delay.
+  EXPECT_EQ(QuicConnection::CalculateNetworkBlackholeDelay(kFourSec, kOneSec,
+                                                           kOneSec),
+            kFourSec);
+
+  EXPECT_EQ(QuicConnection::CalculateNetworkBlackholeDelay(kFourSec, kOneSec,
+                                                           kTwoSec),
+            QuicTime::Delta::FromSeconds(5));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic

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

@@ -166,7 +166,8 @@ void QuicCryptoStream::WriteCryptoData(EncryptionLevel level,
             << absl::StrCat("Too much data for crypto send buffer with level: ",
                             EncryptionLevelToString(level),
                             ", current_buffer_size: ", current_buffer_size,
-                            ", data length: ", data.length());
+                            ", data length: ", data.length(),
+                            ", SNI: ", crypto_negotiated_params().sni);
         OnUnrecoverableError(QUIC_INTERNAL_ERROR,
                              "Too much data for crypto send buffer");
         return;

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

@@ -0,0 +1,31 @@
+// 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/quic_default_clock.h"
+
+#include "absl/time/clock.h"
+
+namespace quic {
+
+QuicDefaultClock* QuicDefaultClock::Get() {
+  static QuicDefaultClock* clock = new QuicDefaultClock();
+  return clock;
+}
+
+QuicTime QuicDefaultClock::ApproximateNow() const { return Now(); }
+
+QuicTime QuicDefaultClock::Now() const {
+  return CreateTimeFromMicroseconds(absl::GetCurrentTimeNanos() / 1000);
+}
+
+QuicWallTime QuicDefaultClock::WallNow() const {
+  return QuicWallTime::FromUNIXMicroseconds(absl::GetCurrentTimeNanos() / 1000);
+}
+
+QuicTime QuicDefaultClock::ConvertWallTimeToQuicTime(
+    const QuicWallTime& walltime) const {
+  return CreateTimeFromMicroseconds(walltime.ToUNIXMicroseconds());
+}
+
+}  // namespace quic