Remove receive_timestamp parameter from QUIC ACK callbacks We take a lot of effort in the code to propagate those, but never use that value. This is probably for the best: ACK-level data should stay at the transport layer, and in the rare cases we decide to give it to the user, we should probably provide a better abstraction than what we have now. There is some code in yperf that does store those values (but never propagates those downstream); I changed it to use local clock just in case someone decides to use that code. PiperOrigin-RevId: 995273766
diff --git a/quiche/quic/core/http/quic_headers_stream.cc b/quiche/quic/core/http/quic_headers_stream.cc index 309e1c1..f7a5964 100644 --- a/quiche/quic/core/http/quic_headers_stream.cc +++ b/quiche/quic/core/http/quic_headers_stream.cc
@@ -58,10 +58,12 @@ } } -bool QuicHeadersStream::OnStreamFrameAcked( - QuicStreamOffset offset, QuicByteCount data_length, bool fin_acked, - QuicTime::Delta ack_delay_time, QuicTime receive_timestamp, - QuicByteCount* newly_acked_length, bool is_retransmission) { +bool QuicHeadersStream::OnStreamFrameAcked(QuicStreamOffset offset, + QuicByteCount data_length, + bool fin_acked, + QuicTime::Delta ack_delay_time, + QuicByteCount* newly_acked_length, + bool is_retransmission) { QuicIntervalSet<QuicStreamOffset> newly_acked(offset, offset + data_length); newly_acked.Difference(bytes_acked()); for (const auto& acked : newly_acked) { @@ -106,8 +108,8 @@ unacked_headers_.pop_front(); } return QuicStream::OnStreamFrameAcked(offset, data_length, fin_acked, - ack_delay_time, receive_timestamp, - newly_acked_length, is_retransmission); + ack_delay_time, newly_acked_length, + is_retransmission); } void QuicHeadersStream::OnStreamFrameRetransmitted(QuicStreamOffset offset,
diff --git a/quiche/quic/core/http/quic_headers_stream.h b/quiche/quic/core/http/quic_headers_stream.h index 6da5485..3dc6c21 100644 --- a/quiche/quic/core/http/quic_headers_stream.h +++ b/quiche/quic/core/http/quic_headers_stream.h
@@ -40,7 +40,6 @@ bool OnStreamFrameAcked(QuicStreamOffset offset, QuicByteCount data_length, bool fin_acked, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, QuicByteCount* newly_acked_length, bool is_retransmission) override;
diff --git a/quiche/quic/core/http/quic_headers_stream_test.cc b/quiche/quic/core/http/quic_headers_stream_test.cc index 8a0f3d9..cd413bc 100644 --- a/quiche/quic/core/http/quic_headers_stream_test.cc +++ b/quiche/quic/core/http/quic_headers_stream_test.cc
@@ -724,35 +724,35 @@ EXPECT_CALL(*ack_listener3, OnPacketAcked(7, _)); EXPECT_CALL(*ack_listener2, OnPacketAcked(7, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 21, 7, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 21, 7, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(7u, newly_acked_length); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 28, 7, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 28, 7, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(7u, newly_acked_length); EXPECT_CALL(*ack_listener3, OnPacketAcked(7, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 35, 7, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 35, 7, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(7u, newly_acked_length); EXPECT_CALL(*ack_listener1, OnPacketAcked(7, _)); EXPECT_CALL(*ack_listener1, OnPacketAcked(7, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 0, 7, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 0, 7, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(7u, newly_acked_length); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 7, 7, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 7, 7, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(7u, newly_acked_length); // Unsent data is acked. EXPECT_CALL(*ack_listener2, OnPacketAcked(7, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 14, 10, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 14, 10, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(7u, newly_acked_length); } @@ -788,22 +788,22 @@ EXPECT_CALL(*ack_listener3, OnPacketAcked(7, _)); EXPECT_CALL(*ack_listener2, OnPacketAcked(2, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 17, 13, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 17, 13, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(13u, newly_acked_length); EXPECT_CALL(*ack_listener2, OnPacketAcked(5, _)); EXPECT_CALL(*ack_listener3, OnPacketAcked(7, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 30, 12, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 30, 12, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(12u, newly_acked_length); EXPECT_CALL(*ack_listener1, OnPacketAcked(14, _)); EXPECT_CALL(*ack_listener2, OnPacketAcked(3, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 0, 17, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 0, 17, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(17u, newly_acked_length); } @@ -832,8 +832,8 @@ QuicByteCount newly_acked_length = 0; EXPECT_CALL(*ack_listener2, OnPacketAcked(5, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 15, 5, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 15, 5, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(5u, newly_acked_length); EXPECT_CALL(*ack_listener1, OnPacketAcked(9, _)); @@ -841,28 +841,28 @@ EXPECT_CALL(*ack_listener2, OnPacketAcked(1, _)); EXPECT_CALL(*ack_listener3, OnPacketAcked(4, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 5, 20, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 5, 20, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(15u, newly_acked_length); // Duplicate ack. EXPECT_FALSE(headers_stream_->OnStreamFrameAcked( - 10, 7, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 10, 7, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(0u, newly_acked_length); EXPECT_CALL(*ack_listener1, OnPacketAcked(5, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 0, 12, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 0, 12, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(5u, newly_acked_length); EXPECT_CALL(*ack_listener3, OnPacketAcked(3, _)); EXPECT_CALL(*ack_listener2, OnPacketAcked(7, _)); EXPECT_CALL(*ack_listener3, OnPacketAcked(7, _)); EXPECT_TRUE(headers_stream_->OnStreamFrameAcked( - 22, 20, false, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 22, 20, false, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(17u, newly_acked_length); }
diff --git a/quiche/quic/core/http/quic_server_session_base.cc b/quiche/quic/core/http/quic_server_session_base.cc index 18754e8..40635a1 100644 --- a/quiche/quic/core/http/quic_server_session_base.cc +++ b/quiche/quic/core/http/quic_server_session_base.cc
@@ -313,10 +313,9 @@ bool QuicServerSessionBase::OnFrameAcked(const quic::QuicFrame& frame, quic::QuicTime::Delta ack_delay_time, - quic::QuicTime receive_timestamp, bool is_retransmission) { - bool result = QuicSpdySession::OnFrameAcked( - frame, ack_delay_time, receive_timestamp, is_retransmission); + bool result = + QuicSpdySession::OnFrameAcked(frame, ack_delay_time, is_retransmission); if (!reset_ssl_after_handshake_ || ssl_reset_) { return result; }
diff --git a/quiche/quic/core/http/quic_server_session_base.h b/quiche/quic/core/http/quic_server_session_base.h index 29395d0..9a138aa 100644 --- a/quiche/quic/core/http/quic_server_session_base.h +++ b/quiche/quic/core/http/quic_server_session_base.h
@@ -79,7 +79,6 @@ // Override to reset the SSL when HANDSHAKE_DONE frame has been ACKed and // there is no unacked crypto data. bool OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool is_retransmission) override; // Override to ignore the crypto frame after resetting the SSL.
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc index 90ae1c2..e1c99fa 100644 --- a/quiche/quic/core/http/quic_spdy_stream.cc +++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -1049,13 +1049,15 @@ } // TODO(danzh): Remove this override once the flag is deprecated. -bool QuicSpdyStream::OnStreamFrameAcked( - QuicStreamOffset offset, QuicByteCount data_length, bool fin_acked, - QuicTime::Delta ack_delay_time, QuicTime receive_timestamp, - QuicByteCount* newly_acked_length, bool is_retransmission) { +bool QuicSpdyStream::OnStreamFrameAcked(QuicStreamOffset offset, + QuicByteCount data_length, + bool fin_acked, + QuicTime::Delta ack_delay_time, + QuicByteCount* newly_acked_length, + bool is_retransmission) { const bool new_data_acked = QuicStream::OnStreamFrameAcked( - offset, data_length, fin_acked, ack_delay_time, receive_timestamp, - newly_acked_length, is_retransmission); + offset, data_length, fin_acked, ack_delay_time, newly_acked_length, + is_retransmission); if (!notify_ack_listener_earlier()) { const QuicByteCount newly_acked_header_length = @@ -1075,12 +1077,10 @@ void QuicSpdyStream::OnNewDataAcked(QuicStreamOffset offset, QuicByteCount data_length, QuicByteCount newly_acked_length, - QuicTime receive_timestamp, QuicTime::Delta ack_delay_time, bool is_retransmission) { QuicStream::OnNewDataAcked(offset, data_length, newly_acked_length, - receive_timestamp, ack_delay_time, - is_retransmission); + ack_delay_time, is_retransmission); const QuicByteCount newly_acked_header_length = GetNumFrameHeadersInInterval(offset, data_length); QUICHE_DCHECK_LE(newly_acked_header_length, newly_acked_length);
diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h index 54d58aa..b2b7543 100644 --- a/quiche/quic/core/http/quic_spdy_stream.h +++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -185,7 +185,6 @@ // Override to report newly acked bytes via ack_listener_. bool OnStreamFrameAcked(QuicStreamOffset offset, QuicByteCount data_length, bool fin_acked, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, QuicByteCount* newly_acked_length, bool is_retransmission) override; @@ -431,7 +430,6 @@ // Called when any new data is acked. void OnNewDataAcked(QuicStreamOffset offset, QuicByteCount data_length, QuicByteCount newly_acked_length, - QuicTime receive_timestamp, QuicTime::Delta ack_delay_time, bool is_retransmission) override;
diff --git a/quiche/quic/core/http/quic_spdy_stream_test.cc b/quiche/quic/core/http/quic_spdy_stream_test.cc index 511a14a..7acbc55 100644 --- a/quiche/quic/core/http/quic_spdy_stream_test.cc +++ b/quiche/quic/core/http/quic_spdy_stream_test.cc
@@ -1807,19 +1807,15 @@ EXPECT_CALL(*ack_listener1, OnPacketAcked(7, _)); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame1), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); EXPECT_CALL(*ack_listener1, OnPacketAcked(5, _)); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame2), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); EXPECT_CALL(*ack_listener2, OnPacketAcked(7, _)); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame3), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); EXPECT_CALL(*ack_listener2, OnPacketAcked(5, _)); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame4), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); } @@ -1890,7 +1886,7 @@ EXPECT_CALL(*mock_ack_listener, OnPacketAcked(9, _)); QuicByteCount newly_acked_length = 0; EXPECT_TRUE(stream_->OnStreamFrameAcked(0, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); // Stream is not waiting for acks as all sent data is acked. EXPECT_FALSE(stream_->IsWaitingForAcks()); @@ -1912,7 +1908,7 @@ // kData2 is acked. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(9, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(9, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); // Stream is waiting for acks as FIN is not acked. EXPECT_TRUE(stream_->IsWaitingForAcks()); @@ -1921,7 +1917,7 @@ // FIN is acked. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(0, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(18, 0, true, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_FALSE(stream_->IsWaitingForAcks()); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); @@ -1949,7 +1945,7 @@ EXPECT_CALL(*mock_ack_listener, OnPacketAcked(9, _)); QuicByteCount newly_acked_length = 0; EXPECT_TRUE(stream_->OnStreamFrameAcked(0, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); // Stream is not waiting for acks as all sent data is acked. EXPECT_FALSE(stream_->IsWaitingForAcks()); @@ -1964,7 +1960,7 @@ // kData2 is acked. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(9, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(9, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); // Stream is waiting for acks as FIN is not acked. EXPECT_TRUE(stream_->IsWaitingForAcks()); @@ -1982,7 +1978,7 @@ } }); EXPECT_TRUE(stream_->OnStreamFrameAcked(18, 0, true, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_FALSE(stream_->IsWaitingForAcks()); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); @@ -2005,19 +2001,19 @@ QuicByteCount newly_acked_length = 0; EXPECT_CALL(*mock_ack_listener, OnPacketAcked(9, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(0, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(2u, QuicStreamPeer::SendBuffer(stream_).size()); // Verify [9, 22) 13 bytes are acked. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(13, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(5, 17, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size()); // Verify [22, 26) 4 bytes are acked. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(4, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(18, 8, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size()); EXPECT_TRUE(stream_->IsWaitingForAcks()); @@ -2026,7 +2022,7 @@ // Verify [26, 27) 1 byte is acked. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(1, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(26, 1, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); EXPECT_TRUE(stream_->IsWaitingForAcks()); @@ -2034,7 +2030,7 @@ // Ack Fin. Verify OnPacketAcked is called. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(0, _)); EXPECT_TRUE(stream_->OnStreamFrameAcked(27, 0, true, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); EXPECT_FALSE(stream_->IsWaitingForAcks()); @@ -2043,8 +2039,8 @@ // No new data is acked, verify OnPacketAcked is not called. EXPECT_CALL(*mock_ack_listener, OnPacketAcked(_, _)).Times(0); EXPECT_FALSE(stream_->OnStreamFrameAcked( - 10, 17, true, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 10, 17, true, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); EXPECT_FALSE(stream_->IsWaitingForAcks()); } @@ -2075,21 +2071,18 @@ QuicStreamFrame frame(stream_->id(), false, 0, absl::StrCat(header.AsStringView(), body)); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); EXPECT_CALL(*mock_ack_listener, OnPacketAcked(0, _)); QuicStreamFrame frame2(stream_->id(), false, header.size() + body.length(), header2.AsStringView()); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame2), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); EXPECT_CALL(*mock_ack_listener, OnPacketAcked(body2.length(), _)); QuicStreamFrame frame3(stream_->id(), true, header.size() + body.length() + header2.size(), body2); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame3), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); EXPECT_TRUE( @@ -2125,7 +2118,6 @@ OnPacketAcked(body1.length() + body2.length(), _)); QuicStreamFrame frame(stream_->id(), true, 0, data1 + data2); EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false)); EXPECT_TRUE(
diff --git a/quiche/quic/core/quic_crypto_stream_test.cc b/quiche/quic/core/quic_crypto_stream_test.cc index a9437da..8eb0a64 100644 --- a/quiche/quic/core/quic_crypto_stream_test.cc +++ b/quiche/quic/core/quic_crypto_stream_test.cc
@@ -494,7 +494,7 @@ // Ack [2000, 2500). QuicByteCount newly_acked_length = 0; stream_->OnStreamFrameAcked(2000, 500, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); EXPECT_EQ(500u, newly_acked_length);
diff --git a/quiche/quic/core/quic_sent_packet_manager.cc b/quiche/quic/core/quic_sent_packet_manager.cc index 0de0ba9..b842b31 100644 --- a/quiche/quic/core/quic_sent_packet_manager.cc +++ b/quiche/quic/core/quic_sent_packet_manager.cc
@@ -624,7 +624,6 @@ void QuicSentPacketManager::MarkPacketHandled(QuicPacketNumber packet_number, QuicTime ack_receive_time, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, QuicTransmissionInfo*& info) { if (info->has_ack_frequency) { for (const auto& frame : info->retransmittable_frames) { @@ -636,13 +635,13 @@ // Try to aggregate acked stream frames if acked packet is not a // retransmission. if (info->transmission_type == NOT_RETRANSMISSION) { - unacked_packets_.MaybeAggregateAckedStreamFrame( - packet_number, ack_delay_time, receive_timestamp, info); + unacked_packets_.MaybeAggregateAckedStreamFrame(packet_number, + ack_delay_time, info); } else { unacked_packets_.NotifyAggregatedStreamFrameAcked(ack_delay_time); info = unacked_packets_.GetMutableTransmissionInfo(packet_number); - const bool new_data_acked = unacked_packets_.NotifyFramesAcked( - packet_number, ack_delay_time, receive_timestamp, info); + const bool new_data_acked = + unacked_packets_.NotifyFramesAcked(packet_number, ack_delay_time, info); if (!new_data_acked && info->transmission_type != NOT_RETRANSMISSION) { // Record as a spurious retransmission if this packet is a // retransmission and no new data gets acked. @@ -1518,8 +1517,7 @@ unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace( packet_number_space, acked_packet.packet_number); MarkPacketHandled(acked_packet.packet_number, ack_receive_time, - last_ack_frame_.ack_delay_time, - acked_packet.receive_timestamp, info); + last_ack_frame_.ack_delay_time, info); } // Copy raw ECN counts to last_ack_frame_ so it is logged properly. Validated // ECN counts are stored in valid_ecn_counts, and the congestion controller
diff --git a/quiche/quic/core/quic_sent_packet_manager.h b/quiche/quic/core/quic_sent_packet_manager.h index dd6dc64..5d6950a 100644 --- a/quiche/quic/core/quic_sent_packet_manager.h +++ b/quiche/quic/core/quic_sent_packet_manager.h
@@ -569,7 +569,6 @@ void MarkPacketHandled(QuicPacketNumber packet_number, QuicTime ack_receive_time, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, QuicTransmissionInfo*& info); // Request that |packet_number| be retransmitted after the other pending
diff --git a/quiche/quic/core/quic_sent_packet_manager_test.cc b/quiche/quic/core/quic_sent_packet_manager_test.cc index 2c4d391..1d176c8 100644 --- a/quiche/quic/core/quic_sent_packet_manager_test.cc +++ b/quiche/quic/core/quic_sent_packet_manager_test.cc
@@ -153,8 +153,7 @@ EXPECT_CALL(notifier_, HasUnackedCryptoData()) .WillRepeatedly(Return(false)); EXPECT_CALL(notifier_, OnStreamFrameRetransmitted(_)).Times(AnyNumber()); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)) - .WillRepeatedly(Return(true)); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).WillRepeatedly(Return(true)); } ~QuicSentPacketManagerTest() override {} @@ -464,7 +463,7 @@ EXPECT_TRUE(manager_.HasInFlightPackets()); VerifyRetransmittablePackets(nullptr, 0); // Ack 2 causes 2 be considered as spurious retransmission. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).WillOnce(Return(false)); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).WillOnce(Return(false)); ExpectAck(2); manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(), clock_.Now()); @@ -604,7 +603,7 @@ // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked. SendDataPacket(4); // No new data gets acked in packet 3. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)) + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)) .WillOnce(Return(false)) .WillRepeatedly(Return(true)); uint64_t acked[] = {3, 4}; @@ -709,7 +708,7 @@ // data gets acked. ExpectAck(5); EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _)); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).WillOnce(Return(false)); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).WillOnce(Return(false)); manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(), clock_.Now()); manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6)); @@ -1672,7 +1671,7 @@ *send_algorithm_, OnCongestionEvent(/*rtt_updated=*/true, kDefaultLength, _, _, _, _, _)); EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)); EXPECT_EQ(PACKETS_NEWLY_ACKED, manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3), ENCRYPTION_FORWARD_SECURE, kEmptyCounts)); @@ -1706,7 +1705,7 @@ EXPECT_CALL(*send_algorithm_, OnCongestionEvent(/*rtt_updated=*/false, 0, _, _, _, _, _)); EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)); EXPECT_EQ(PACKETS_NEWLY_ACKED, manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3), ENCRYPTION_FORWARD_SECURE, kEmptyCounts)); @@ -2621,13 +2620,12 @@ SendDataPacket(2, ENCRYPTION_HANDSHAKE); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)) - .WillOnce([](const QuicFrame& /*frame*/, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool) { - EXPECT_TRUE(ack_delay_time.IsZero()); - EXPECT_EQ(receive_timestamp, QuicTime::Zero()); - return true; - }); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)) + .WillOnce( + [](const QuicFrame& /*frame*/, QuicTime::Delta ack_delay_time, bool) { + EXPECT_TRUE(ack_delay_time.IsZero()); + return true; + }); EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(2))).Times(1); manager_.SetHandshakeConfirmed(); @@ -2638,7 +2636,7 @@ SendCryptoPacket(1); SendPingPacket(2, ENCRYPTION_INITIAL); // Crypto data has been discarded but ping does not. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)) + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)) .Times(2) .WillOnce(Return(false)) .WillOnce(Return(true));
diff --git a/quiche/quic/core/quic_session.cc b/quiche/quic/core/quic_session.cc index 01c10e2..1de1652 100644 --- a/quiche/quic/core/quic_session.cc +++ b/quiche/quic/core/quic_session.cc
@@ -2580,10 +2580,9 @@ bool QuicSession::OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool is_retransmission) { if (frame.type == DATAGRAM_FRAME) { - OnDatagramAcked(frame.datagram_frame->datagram_id, receive_timestamp); + OnDatagramAcked(frame.datagram_frame->datagram_id); return true; } if (frame.type == CRYPTO_FRAME) { @@ -2607,8 +2606,8 @@ QuicByteCount newly_acked_length = 0; new_stream_data_acked = stream->OnStreamFrameAcked( frame.stream_frame.offset, frame.stream_frame.data_length, - frame.stream_frame.fin, ack_delay_time, receive_timestamp, - &newly_acked_length, is_retransmission); + frame.stream_frame.fin, ack_delay_time, &newly_acked_length, + is_retransmission); connection_->mutable_stats().application_data_acked += newly_acked_length; if (!stream->HasPendingRetransmission()) { streams_with_pending_retransmission_.erase(stream->id()); @@ -2899,8 +2898,7 @@ return {result, 0}; } -void QuicSession::OnDatagramAcked(QuicDatagramId datagram_id, - QuicTime /*receive_timestamp*/) { +void QuicSession::OnDatagramAcked(QuicDatagramId datagram_id) { QUIC_DVLOG(1) << ENDPOINT << "datagram " << datagram_id << " gets acked."; }
diff --git a/quiche/quic/core/quic_session.h b/quiche/quic/core/quic_session.h index 6faed44..ed584a7 100644 --- a/quiche/quic/core/quic_session.h +++ b/quiche/quic/core/quic_session.h
@@ -369,7 +369,6 @@ // SessionNotifierInterface methods: bool OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool is_retransmission) override; void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override; void OnFrameLost(const QuicFrame& frame) override; @@ -430,8 +429,7 @@ DatagramResult SendDatagram(quiche::QuicheMemSlice datagram); // Called when datagram with |datagram_id| gets acked. - virtual void OnDatagramAcked(QuicDatagramId datagram_id, - QuicTime receive_timestamp); + virtual void OnDatagramAcked(QuicDatagramId datagram_id); // Called when datagram with |datagram_id| is considered as lost. virtual void OnDatagramLost(QuicDatagramId datagram_id);
diff --git a/quiche/quic/core/quic_session_test.cc b/quiche/quic/core/quic_session_test.cc index e3d4df9..fb99da4 100644 --- a/quiche/quic/core/quic_session_test.cc +++ b/quiche/quic/core/quic_session_test.cc
@@ -1365,7 +1365,7 @@ EXPECT_CALL(*connection_, SendControlFrame(IsFrame(MAX_STREAMS_FRAME))) .WillOnce(&ClearControlFrame); session_.OnFrameAcked(QuicFrame(max_stream_frames[0]), - QuicTime::Delta::Zero(), QuicTime::Zero(), + QuicTime::Delta::Zero(), /*is_retransmission=*/false); EXPECT_EQ(3 * kMaxStreams, QuicSessionPeer::ietf_streamid_manager(&session_) @@ -1385,7 +1385,7 @@ // When the remaining outstanding MAX_STREAMS frame is ACK'd no new one // will be sent because the correct limit has already been advertised. session_.OnFrameAcked(QuicFrame(max_stream_frames[1]), - QuicTime::Delta::Zero(), QuicTime::Zero(), + QuicTime::Delta::Zero(), /*is_retransmission=*/false); } @@ -2786,7 +2786,7 @@ EXPECT_FALSE(session_.IsFrameOutstanding(QuicFrame(&frame2))); // datagram 1 gets acked. - session_.OnDatagramAcked(1, QuicTime::Zero()); + session_.OnDatagramAcked(1); EXPECT_FALSE(session_.IsFrameOutstanding(QuicFrame(&frame))); }
diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc index 2b98540..dbd55a5 100644 --- a/quiche/quic/core/quic_stream.cc +++ b/quiche/quic/core/quic_stream.cc
@@ -1249,7 +1249,6 @@ bool QuicStream::OnStreamFrameAcked(QuicStreamOffset offset, QuicByteCount data_length, bool fin_acked, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, QuicByteCount* newly_acked_length, bool is_retransmission) { QUIC_DVLOG(1) << ENDPOINT << "stream " << id_ << " Acking " @@ -1282,8 +1281,8 @@ } if (notify_ack_listener_earlier_ && new_data_acked) { QUIC_RELOADABLE_FLAG_COUNT_N(quic_notify_ack_listener_earlier, 1, 3); - OnNewDataAcked(offset, data_length, *newly_acked_length, receive_timestamp, - ack_delay_time, is_retransmission); + OnNewDataAcked(offset, data_length, *newly_acked_length, ack_delay_time, + is_retransmission); } if (!IsWaitingForAcks() && read_side_closed_ && write_side_closed_) { session_->MaybeCloseZombieStream(id_); @@ -1294,7 +1293,6 @@ void QuicStream::OnNewDataAcked(QuicStreamOffset /*offset*/, QuicByteCount /*data_length*/, QuicByteCount /*newly_acked_length*/, - QuicTime /*receive_timestamp*/, QuicTime::Delta /*ack_delay_time*/, bool /*is_retransmission*/) { QUICHE_DCHECK(notify_ack_listener_earlier_);
diff --git a/quiche/quic/core/quic_stream.h b/quiche/quic/core/quic_stream.h index 517b551..e9be2d5 100644 --- a/quiche/quic/core/quic_stream.h +++ b/quiche/quic/core/quic_stream.h
@@ -369,7 +369,6 @@ virtual bool OnStreamFrameAcked(QuicStreamOffset offset, QuicByteCount data_length, bool fin_acked, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, QuicByteCount* newly_acked_length, bool is_retransmission); @@ -517,7 +516,6 @@ virtual void OnNewDataAcked(QuicStreamOffset offset, QuicByteCount data_length, QuicByteCount newly_acked_length, - QuicTime receive_timestamp, QuicTime::Delta ack_delay_time, bool is_retransmission);
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc index e3d2b2b..8ebaf35 100644 --- a/quiche/quic/core/quic_stream_test.cc +++ b/quiche/quic/core/quic_stream_test.cc
@@ -967,7 +967,7 @@ EXPECT_TRUE(stream_->IsWaitingForAcks()); QuicByteCount newly_acked_length = 0; EXPECT_TRUE(stream_->OnStreamFrameAcked(0, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(9u, newly_acked_length); // Stream is not waiting for acks as all sent data is acked. @@ -990,7 +990,7 @@ // kData2 is acked. EXPECT_TRUE(stream_->OnStreamFrameAcked(9, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(9u, newly_acked_length); // Stream is waiting for acks as FIN is not acked. @@ -1001,7 +1001,7 @@ // FIN is acked. EXPECT_CALL(*stream_, OnWriteSideInDataRecvdState()); EXPECT_TRUE(stream_->OnStreamFrameAcked(18, 0, true, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(0u, newly_acked_length); EXPECT_FALSE(stream_->IsWaitingForAcks()); @@ -1023,19 +1023,19 @@ EXPECT_TRUE(session_->HasUnackedStreamData()); QuicByteCount newly_acked_length = 0; EXPECT_TRUE(stream_->OnStreamFrameAcked(9, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_TRUE(session_->HasUnackedStreamData()); EXPECT_EQ(9u, newly_acked_length); EXPECT_EQ(3u, QuicStreamPeer::SendBuffer(stream_).size()); EXPECT_TRUE(stream_->OnStreamFrameAcked(18, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_TRUE(session_->HasUnackedStreamData()); EXPECT_EQ(9u, newly_acked_length); EXPECT_EQ(3u, QuicStreamPeer::SendBuffer(stream_).size()); EXPECT_TRUE(stream_->OnStreamFrameAcked(0, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_TRUE(session_->HasUnackedStreamData()); EXPECT_EQ(9u, newly_acked_length); @@ -1045,7 +1045,7 @@ EXPECT_TRUE(session_->HasUnackedStreamData()); EXPECT_CALL(*stream_, OnWriteSideInDataRecvdState()); EXPECT_TRUE(stream_->OnStreamFrameAcked(27, 0, true, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(0u, newly_acked_length); EXPECT_FALSE(stream_->IsWaitingForAcks()); @@ -1408,19 +1408,19 @@ // Verify [0, 9) 9 bytes are acked. QuicByteCount newly_acked_length = 0; EXPECT_TRUE(stream_->OnStreamFrameAcked(0, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(9u, newly_acked_length); EXPECT_EQ(2u, QuicStreamPeer::SendBuffer(stream_).size()); // Verify [9, 22) 13 bytes are acked. EXPECT_TRUE(stream_->OnStreamFrameAcked(5, 17, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(13u, newly_acked_length); EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size()); // Verify [22, 26) 4 bytes are acked. EXPECT_TRUE(stream_->OnStreamFrameAcked(18, 8, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(4u, newly_acked_length); EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size()); @@ -1429,7 +1429,7 @@ // Ack [0, 27). Verify [26, 27) 1 byte is acked. EXPECT_TRUE(stream_->OnStreamFrameAcked(26, 1, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(1u, newly_acked_length); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); @@ -1439,7 +1439,7 @@ // Ack Fin. EXPECT_CALL(*stream_, OnWriteSideInDataRecvdState()).Times(1); EXPECT_TRUE(stream_->OnStreamFrameAcked(27, 0, true, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(0u, newly_acked_length); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); @@ -1448,8 +1448,8 @@ // Ack [10, 27) and fin. No new data is acked. EXPECT_FALSE(stream_->OnStreamFrameAcked( - 10, 17, true, QuicTime::Delta::Zero(), QuicTime::Zero(), - &newly_acked_length, /*is_retransmission=*/false)); + 10, 17, true, QuicTime::Delta::Zero(), &newly_acked_length, + /*is_retransmission=*/false)); EXPECT_EQ(0u, newly_acked_length); EXPECT_EQ(0u, QuicStreamPeer::SendBuffer(stream_).size()); EXPECT_FALSE(stream_->IsWaitingForAcks()); @@ -1504,7 +1504,7 @@ // Ack [9, 18). QuicByteCount newly_acked_length = 0; EXPECT_TRUE(stream_->OnStreamFrameAcked(9, 9, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false)); EXPECT_EQ(9u, newly_acked_length); EXPECT_FALSE(stream_->IsStreamFrameOutstanding(9, 3, false)); @@ -1623,7 +1623,7 @@ // Ack [10, 13). QuicByteCount newly_acked_length = 0; stream_->OnStreamFrameAcked(10, 3, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); EXPECT_EQ(3u, newly_acked_length); // Retransmit [0, 18) with fin, and only [0, 8) is consumed. @@ -1956,7 +1956,7 @@ EXPECT_CALL(*stream_, OnWriteSideInDataRecvdState()).Times(1); EXPECT_CALL(*connection_, OnStreamReset(stream_->id(), _)).Times(1); stream_->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); std::vector<std::unique_ptr<QuicStream>>* closed_streams = session_->ClosedStreams(); @@ -2000,7 +2000,7 @@ EXPECT_CALL(*stream_, OnWriteSideInDataRecvdState()).Times(1); EXPECT_CALL(*connection_, OnStreamReset(stream_->id(), _)).Times(1); stream_->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); std::vector<std::unique_ptr<QuicStream>>* closed_streams = session_->ClosedStreams(); @@ -2039,7 +2039,7 @@ EXPECT_CALL(*stream_, OnWriteSideInDataRecvdState()).Times(1); EXPECT_CALL(*connection_, OnStreamReset(stream_->id(), _)).Times(1); stream_->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); ASSERT_EQ(closed_streams->size(), 1); EXPECT_EQ((*(closed_streams->begin()))->id(), stream_->id()); @@ -2073,7 +2073,7 @@ EXPECT_CALL(*stream_, OnWriteSideInDataRecvdState()).Times(1); EXPECT_CALL(*connection_, OnStreamReset(stream_->id(), _)).Times(1); stream_->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); ASSERT_TRUE(closed_streams->empty()); // The rest of the stream arrives. @@ -2105,7 +2105,7 @@ SendApplicationData(data, 100, false); QuicByteCount newly_acked_length = 0; stream_->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); EXPECT_CALL(*session_, MaybeSendResetStreamAtFrame(_, _, _, _)).Times(1); EXPECT_TRUE(stream_->SetReliableSize()); @@ -2140,7 +2140,7 @@ EXPECT_CALL(*connection_, OnStreamReset(stream_->id(), _)).Times(1); QuicByteCount newly_acked_length = 0; stream_->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); } @@ -2225,7 +2225,7 @@ ; QuicByteCount newly_acked_length = 0; stream_ptr->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); std::vector<std::unique_ptr<QuicStream>>* closed_streams = session_->ClosedStreams(); @@ -2258,7 +2258,7 @@ EXPECT_CALL(*connection_, OnStreamReset(stream_id, _)).Times(1); QuicByteCount newly_acked_length = 0; stream_->OnStreamFrameAcked(0, 100, false, QuicTime::Delta::Zero(), - QuicTime::Zero(), &newly_acked_length, + &newly_acked_length, /*is_retransmission=*/false); std::vector<std::unique_ptr<QuicStream>>* closed_streams = session_->ClosedStreams();
diff --git a/quiche/quic/core/quic_unacked_packet_map.cc b/quiche/quic/core/quic_unacked_packet_map.cc index 12c2837..55735b4 100644 --- a/quiche/quic/core/quic_unacked_packet_map.cc +++ b/quiche/quic/core/quic_unacked_packet_map.cc
@@ -386,8 +386,7 @@ // send algorithm). // TODO(b/148868195): use NotifyFramesNeutered. QuicTransmissionInfo* info = &(*it); - NotifyFramesAcked(packet_number, QuicTime::Delta::Zero(), - QuicTime::Zero(), info); + NotifyFramesAcked(packet_number, QuicTime::Delta::Zero(), info); QUICHE_DCHECK(!HasRetransmittableFrames(*info)); } } @@ -413,8 +412,7 @@ neutered_packets.push_back(packet_number); // TODO(b/148868195): use NotifyFramesNeutered. QuicTransmissionInfo* info = &(*it); - NotifyFramesAcked(packet_number, QuicTime::Delta::Zero(), - QuicTime::Zero(), info); + NotifyFramesAcked(packet_number, QuicTime::Delta::Zero(), info); } } QUICHE_DCHECK(!supports_multiple_packet_number_spaces() || @@ -496,7 +494,6 @@ bool QuicUnackedPacketMap::NotifyFramesAcked(QuicPacketNumber packet_number, QuicTime::Delta ack_delay, - QuicTime receive_timestamp, QuicTransmissionInfo*& info) { if (session_notifier_ == nullptr) { return false; @@ -532,8 +529,7 @@ }; for (const QuicFrame& frame : *frames) { - if (session_notifier_->OnFrameAcked(frame, ack_delay, receive_timestamp, - is_retransmission)) { + if (session_notifier_->OnFrameAcked(frame, ack_delay, is_retransmission)) { new_data_acked = true; } } @@ -554,7 +550,7 @@ void QuicUnackedPacketMap::MaybeAggregateAckedStreamFrame( QuicPacketNumber packet_number, QuicTime::Delta ack_delay, - QuicTime receive_timestamp, QuicTransmissionInfo*& info) { + QuicTransmissionInfo*& info) { if (session_notifier_ == nullptr) { return; } @@ -613,7 +609,7 @@ NotifyAggregatedStreamFrameAcked(ack_delay); if (frame.type != STREAM_FRAME || frame.stream_frame.fin) { - session_notifier_->OnFrameAcked(frame, ack_delay, receive_timestamp, + session_notifier_->OnFrameAcked(frame, ack_delay, /*is_retransmission=*/false); continue; } @@ -634,12 +630,10 @@ // Aggregated stream frame is empty. return; } - // Note: there is no receive_timestamp for an aggregated stream frame. The - // frames that are aggregated may not have been received at the same time. // We only aggregate stream frames that are not retransmissions. - session_notifier_->OnFrameAcked( - QuicFrame(aggregated_stream_frame_), ack_delay, - /*receive_timestamp=*/QuicTime::Zero(), /*is_retransmission=*/false); + session_notifier_->OnFrameAcked(QuicFrame(aggregated_stream_frame_), + ack_delay, + /*is_retransmission=*/false); // Clear aggregated stream frame. aggregated_stream_frame_.stream_id = -1; }
diff --git a/quiche/quic/core/quic_unacked_packet_map.h b/quiche/quic/core/quic_unacked_packet_map.h index 9377b6e..dcc36f6 100644 --- a/quiche/quic/core/quic_unacked_packet_map.h +++ b/quiche/quic/core/quic_unacked_packet_map.h
@@ -59,7 +59,7 @@ // to move, in that case, |info| will be updated to point to the new // QuicTransmissionInfo when the function returns. bool NotifyFramesAcked(QuicPacketNumber packet_number, - QuicTime::Delta ack_delay, QuicTime receive_timestamp, + QuicTime::Delta ack_delay, QuicTransmissionInfo*& info); // Notifies session_notifier that frames in |info| are considered as lost. @@ -197,7 +197,6 @@ // QuicTransmissionInfo when the function returns. void MaybeAggregateAckedStreamFrame(QuicPacketNumber packet_number, QuicTime::Delta ack_delay, - QuicTime receive_timestamp, QuicTransmissionInfo*& info); // Notify the session notifier of any stream data aggregated in
diff --git a/quiche/quic/core/quic_unacked_packet_map_test.cc b/quiche/quic/core/quic_unacked_packet_map_test.cc index bbcf9b8..242cc8b 100644 --- a/quiche/quic/core/quic_unacked_packet_map_test.cc +++ b/quiche/quic/core/quic_unacked_packet_map_test.cc
@@ -472,7 +472,7 @@ TEST_P(QuicUnackedPacketMapTest, AggregateContiguousAckedStreamFrames) { testing::InSequence s; - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(0); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0); unacked_packets_.NotifyAggregatedStreamFrameAcked(QuicTime::Delta::Zero()); SerializedPacket packet1( @@ -505,20 +505,20 @@ unacked_packets_.GetMutableTransmissionInfo(QuicPacketNumber(4)); // Verify stream frames are aggregated. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(0); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(1), QuicTime::Delta::Zero(), QuicTime::Zero(), info1); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(0); + QuicPacketNumber(1), QuicTime::Delta::Zero(), info1); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(2), QuicTime::Delta::Zero(), QuicTime::Zero(), info2); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(0); + QuicPacketNumber(2), QuicTime::Delta::Zero(), info2); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(3), QuicTime::Delta::Zero(), QuicTime::Zero(), info3); + QuicPacketNumber(3), QuicTime::Delta::Zero(), info3); // Verify aggregated stream frame gets acked since fin is acked. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(1); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(1); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(4), QuicTime::Delta::Zero(), QuicTime::Zero(), info4); + QuicPacketNumber(4), QuicTime::Delta::Zero(), info4); } // Regression test for b/112930090. @@ -552,19 +552,17 @@ if (aggregated_stream_frame.data_length + acked_stream_length <= kMaxAggregatedDataLength) { // Verify the acked stream frame can be aggregated. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(0); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(packet_number), QuicTime::Delta::Zero(), - QuicTime::Zero(), info); + QuicPacketNumber(packet_number), QuicTime::Delta::Zero(), info); aggregated_data_length += acked_stream_length; testing::Mock::VerifyAndClearExpectations(¬ifier_); } else { // Verify the acked stream frame cannot be aggregated because // data_length is overflow. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(1); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(1); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(packet_number), QuicTime::Delta::Zero(), - QuicTime::Zero(), info); + QuicPacketNumber(packet_number), QuicTime::Delta::Zero(), info); aggregated_data_length = acked_stream_length; testing::Mock::VerifyAndClearExpectations(¬ifier_); } @@ -581,10 +579,9 @@ true, ECN_NOT_ECT); QuicTransmissionInfo* info = unacked_packets_.GetMutableTransmissionInfo( QuicPacketNumber(packet_number)); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(1); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(1); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(packet_number), QuicTime::Delta::Zero(), - QuicTime::Zero(), info); + QuicPacketNumber(packet_number), QuicTime::Delta::Zero(), info); testing::Mock::VerifyAndClearExpectations(¬ifier_); } } @@ -614,15 +611,15 @@ unacked_packets_.GetMutableTransmissionInfo(QuicPacketNumber(2)); // Verify 2 contiguous stream frames are aggregated. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(1); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(1); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(1), QuicTime::Delta::Zero(), QuicTime::Zero(), info1); + QuicPacketNumber(1), QuicTime::Delta::Zero(), info1); // Verify aggregated stream frame gets acked. - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(3); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(3); unacked_packets_.MaybeAggregateAckedStreamFrame( - QuicPacketNumber(2), QuicTime::Delta::Zero(), QuicTime::Zero(), info2); + QuicPacketNumber(2), QuicTime::Delta::Zero(), info2); - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)).Times(0); + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0); unacked_packets_.NotifyAggregatedStreamFrameAcked(QuicTime::Delta::Zero()); } @@ -647,8 +644,8 @@ int last_padding_bytes = last_info->retransmittable_frames[0].padding_frame.num_padding_bytes; - EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _)) - .WillOnce([&](const QuicFrame& frame, QuicTime::Delta, QuicTime, bool) { + EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)) + .WillOnce([&](const QuicFrame& frame, QuicTime::Delta, bool) { EXPECT_EQ(frame.type, PADDING_FRAME); EXPECT_EQ(frame.padding_frame.num_padding_bytes, last_padding_bytes); // Append one more packet to the unacked packet map. @@ -661,7 +658,7 @@ QuicTransmissionInfo* last_info_updated = last_info; unacked_packets_.NotifyFramesAcked(largest_sent_packet_before_acked, - QuicTime::Delta::Zero(), QuicTime::Zero(), + QuicTime::Delta::Zero(), last_info_updated); EXPECT_NE(last_info, last_info_updated); EXPECT_EQ(unacked_packets_.GetMutableTransmissionInfo(
diff --git a/quiche/quic/core/session_notifier_interface.h b/quiche/quic/core/session_notifier_interface.h index 452abd2..66cfce6 100644 --- a/quiche/quic/core/session_notifier_interface.h +++ b/quiche/quic/core/session_notifier_interface.h
@@ -20,7 +20,6 @@ // returns false otherwise. virtual bool OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool is_retransmission) = 0; // Called when |frame| is retransmitted.
diff --git a/quiche/quic/masque/masque_client_session.cc b/quiche/quic/masque/masque_client_session.cc index fcf7cae..1dbc686 100644 --- a/quiche/quic/masque/masque_client_session.cc +++ b/quiche/quic/masque/masque_client_session.cc
@@ -87,8 +87,7 @@ crypto_config), owner_(owner) {} -void MasqueClientSession::OnDatagramAcked(QuicDatagramId datagram_id, - QuicTime /*receive_timestamp*/) { +void MasqueClientSession::OnDatagramAcked(QuicDatagramId datagram_id) { QUIC_DVLOG(1) << "Received ack for DATAGRAM frame " << datagram_id; }
diff --git a/quiche/quic/masque/masque_client_session.h b/quiche/quic/masque/masque_client_session.h index f3aac5e..89765f7 100644 --- a/quiche/quic/masque/masque_client_session.h +++ b/quiche/quic/masque/masque_client_session.h
@@ -134,8 +134,7 @@ MasqueClientSession& operator=(const MasqueClientSession&) = delete; // From QuicSession. - void OnDatagramAcked(QuicDatagramId datagram_id, - QuicTime receive_timestamp) override; + void OnDatagramAcked(QuicDatagramId datagram_id) override; void OnDatagramLost(QuicDatagramId datagram_id) override; void OnConnectionClosed(const QuicConnectionCloseFrame& frame, ConnectionCloseSource source) override;
diff --git a/quiche/quic/masque/masque_server_session.cc b/quiche/quic/masque/masque_server_session.cc index 5b3b7b0..85a0fdb 100644 --- a/quiche/quic/masque/masque_server_session.cc +++ b/quiche/quic/masque/masque_server_session.cc
@@ -172,8 +172,7 @@ (void)masque_mode_; } -void MasqueServerSession::OnDatagramAcked(QuicDatagramId datagram_id, - QuicTime /*receive_timestamp*/) { +void MasqueServerSession::OnDatagramAcked(QuicDatagramId datagram_id) { QUIC_DVLOG(1) << "Received ack for DATAGRAM frame " << datagram_id; }
diff --git a/quiche/quic/masque/masque_server_session.h b/quiche/quic/masque/masque_server_session.h index ab9b666..7845a30 100644 --- a/quiche/quic/masque/masque_server_session.h +++ b/quiche/quic/masque/masque_server_session.h
@@ -65,8 +65,7 @@ MasqueServerSession& operator=(const MasqueServerSession&) = delete; // From QuicSession. - void OnDatagramAcked(QuicDatagramId datagram_id, - QuicTime receive_timestamp) override; + void OnDatagramAcked(QuicDatagramId datagram_id) override; void OnDatagramLost(QuicDatagramId datagram_id) override; void OnConnectionClosed(const QuicConnectionCloseFrame& frame, ConnectionCloseSource source) override;
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h index fd8cbf1..ba59ea3 100644 --- a/quiche/quic/test_tools/quic_test_utils.h +++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -1457,8 +1457,8 @@ MockSessionNotifier(); ~MockSessionNotifier() override; - MOCK_METHOD(bool, OnFrameAcked, - (const QuicFrame&, QuicTime::Delta, QuicTime, bool), (override)); + MOCK_METHOD(bool, OnFrameAcked, (const QuicFrame&, QuicTime::Delta, bool), + (override)); MOCK_METHOD(void, OnStreamFrameRetransmitted, (const QuicStreamFrame&), (override)); MOCK_METHOD(void, OnFrameLost, (const QuicFrame&), (override));
diff --git a/quiche/quic/test_tools/simple_session_notifier.cc b/quiche/quic/test_tools/simple_session_notifier.cc index 0e854bd..80e8bb3 100644 --- a/quiche/quic/test_tools/simple_session_notifier.cc +++ b/quiche/quic/test_tools/simple_session_notifier.cc
@@ -189,7 +189,7 @@ QuicCryptoFrame crypto_frame(ENCRYPTION_INITIAL, interval.min(), interval.max() - interval.min()); OnFrameAcked(QuicFrame(&crypto_frame), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false); + /*is_retransmission=*/false); } return; } @@ -198,7 +198,7 @@ QuicUtils::GetCryptoStreamId(connection_->transport_version()), false, interval.min(), interval.max() - interval.min()); OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false); + /*is_retransmission=*/false); } } @@ -285,7 +285,6 @@ bool SimpleSessionNotifier::OnFrameAcked(const QuicFrame& frame, QuicTime::Delta /*ack_delay_time*/, - QuicTime /*receive_timestamp*/, bool /*is_retransmission*/) { QUIC_DVLOG(1) << "Acking " << frame; if (frame.type == CRYPTO_FRAME) {
diff --git a/quiche/quic/test_tools/simple_session_notifier.h b/quiche/quic/test_tools/simple_session_notifier.h index eec1b6a..7637a33 100644 --- a/quiche/quic/test_tools/simple_session_notifier.h +++ b/quiche/quic/test_tools/simple_session_notifier.h
@@ -86,7 +86,6 @@ // SessionNotifierInterface methods: bool OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool is_retransmission) override; void OnStreamFrameRetransmitted(const QuicStreamFrame& /*frame*/) override {} void OnFrameLost(const QuicFrame& frame) override;
diff --git a/quiche/quic/test_tools/simple_session_notifier_test.cc b/quiche/quic/test_tools/simple_session_notifier_test.cc index 6206b8c..0f2bc49 100644 --- a/quiche/quic/test_tools/simple_session_notifier_test.cc +++ b/quiche/quic/test_tools/simple_session_notifier_test.cc
@@ -164,7 +164,7 @@ QuicUtils::GetCryptoStreamId(connection_.transport_version()), false, 1024, 1024); notifier_.OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false); + /*is_retransmission=*/false); EXPECT_TRUE(notifier_.StreamIsWaitingForAcks( QuicUtils::GetCryptoStreamId(connection_.transport_version()))); EXPECT_TRUE(notifier_.HasUnackedStreamData()); @@ -338,9 +338,9 @@ QuicStreamFrame ack_frame1(3, false, 3, 4); QuicStreamFrame ack_frame2(5, false, 8, 2); notifier_.OnFrameAcked(QuicFrame(ack_frame1), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false); + /*is_retransmission=*/false); notifier_.OnFrameAcked(QuicFrame(ack_frame2), QuicTime::Delta::Zero(), - QuicTime::Zero(), /*is_retransmission=*/false); + /*is_retransmission=*/false); EXPECT_FALSE(notifier_.WillingToWrite()); // Force to send.
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint.cc b/quiche/quic/test_tools/simulator/quic_endpoint.cc index 433e16d..5823849 100644 --- a/quiche/quic/test_tools/simulator/quic_endpoint.cc +++ b/quiche/quic/test_tools/simulator/quic_endpoint.cc
@@ -171,11 +171,9 @@ bool QuicEndpoint::OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool is_retransmission) { if (notifier_ != nullptr) { - return notifier_->OnFrameAcked(frame, ack_delay_time, receive_timestamp, - is_retransmission); + return notifier_->OnFrameAcked(frame, ack_delay_time, is_retransmission); } return false; }
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint.h b/quiche/quic/test_tools/simulator/quic_endpoint.h index c47a156..8db38e3 100644 --- a/quiche/quic/test_tools/simulator/quic_endpoint.h +++ b/quiche/quic/test_tools/simulator/quic_endpoint.h
@@ -120,7 +120,6 @@ // Begin SessionNotifierInterface methods: bool OnFrameAcked(const QuicFrame& frame, QuicTime::Delta ack_delay_time, - QuicTime receive_timestamp, bool is_retransmission) override; void OnStreamFrameRetransmitted(const QuicStreamFrame& /*frame*/) override {} void OnFrameLost(const QuicFrame& frame) override;