gfe-relnote: Pass receive_timestamp to OnMessageAcked().
When receive timestamps are turned on and message frames are enabled, this will
make receive timestamps available to the session whenever a message is acked.
This will be used for RTP over QUIC, where ack timestamps are required for RTP's
congestion controller and media adaptation. (The current implementation uses
QUIC like a tunnel and disables its congestion control.)
Not flag-protected: no change in behavior, just a change in what is visible
where.
PiperOrigin-RevId: 250703980
Change-Id: I01bcee29d5dfb808771c54e4fd14ebbfa8750375
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 60e7430..b6e59a5 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -1406,17 +1406,17 @@
session_->OnStreamFrameRetransmitted(frame1);
EXPECT_CALL(*ack_listener1, OnPacketAcked(7, _));
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame1), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame1), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
EXPECT_CALL(*ack_listener1, OnPacketAcked(5, _));
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame2), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame2), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
EXPECT_CALL(*ack_listener2, OnPacketAcked(7, _));
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame3), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame3), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
EXPECT_CALL(*ack_listener2, OnPacketAcked(5, _));
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame4), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame4), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
}
TEST_P(QuicSpdyStreamTest, StreamBecomesZombieWithWriteThatCloses) {
@@ -1631,20 +1631,20 @@
EXPECT_CALL(*mock_ack_listener, OnPacketAcked(body.length(), _));
QuicStreamFrame frame(stream_->id(), false, 0, header + body);
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
EXPECT_CALL(*mock_ack_listener, OnPacketAcked(0, _));
QuicStreamFrame frame2(stream_->id(), false, (header + body).length(),
header2);
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame2), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame2), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
EXPECT_CALL(*mock_ack_listener, OnPacketAcked(body2.length(), _));
QuicStreamFrame frame3(stream_->id(), true,
(header + body).length() + header2.length(), body2);
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame3), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame3), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
EXPECT_TRUE(
QuicSpdyStreamPeer::unacked_frame_headers_offsets(stream_).Empty());
@@ -1688,8 +1688,8 @@
OnPacketAcked(body.length() + body2.length(), _));
QuicStreamFrame frame(stream_->id(), true, 0,
header + body + header2 + body2);
- EXPECT_TRUE(
- session_->OnFrameAcked(QuicFrame(frame), QuicTime::Delta::Zero()));
+ EXPECT_TRUE(session_->OnFrameAcked(QuicFrame(frame), QuicTime::Delta::Zero(),
+ QuicTime::Zero()));
EXPECT_TRUE(
QuicSpdyStreamPeer::unacked_frame_headers_offsets(stream_).Empty());
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 527f820..204c020 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -610,7 +610,8 @@
void QuicSentPacketManager::MarkPacketHandled(QuicPacketNumber packet_number,
QuicTransmissionInfo* info,
- QuicTime::Delta ack_delay_time) {
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) {
QuicPacketNumber newest_transmission =
GetNewestRetransmission(packet_number, *info);
// Remove the most recent packet, if it is pending retransmission.
@@ -622,13 +623,14 @@
const bool fast_path = session_decides_what_to_write() &&
info->transmission_type == NOT_RETRANSMISSION;
if (fast_path) {
- unacked_packets_.MaybeAggregateAckedStreamFrame(*info, ack_delay_time);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(*info, ack_delay_time,
+ receive_timestamp);
} else {
if (session_decides_what_to_write()) {
unacked_packets_.NotifyAggregatedStreamFrameAcked(ack_delay_time);
}
- const bool new_data_acked =
- unacked_packets_.NotifyFramesAcked(*info, ack_delay_time);
+ const bool new_data_acked = unacked_packets_.NotifyFramesAcked(
+ *info, ack_delay_time, receive_timestamp);
if (session_decides_what_to_write() && !new_data_acked &&
info->transmission_type != NOT_RETRANSMISSION) {
// Record as a spurious retransmission if this packet is a
@@ -651,8 +653,8 @@
// only handle nullptr encrypted packets in a special way.
const QuicTransmissionInfo& newest_transmission_info =
unacked_packets_.GetTransmissionInfo(newest_transmission);
- unacked_packets_.NotifyFramesAcked(newest_transmission_info,
- ack_delay_time);
+ unacked_packets_.NotifyFramesAcked(newest_transmission_info, ack_delay_time,
+ receive_timestamp);
if (HasCryptoHandshake(newest_transmission_info)) {
unacked_packets_.RemoveFromInFlight(newest_transmission);
}
@@ -1241,7 +1243,8 @@
packet_number_space, acked_packet.packet_number);
}
MarkPacketHandled(acked_packet.packet_number, info,
- last_ack_frame_.ack_delay_time);
+ last_ack_frame_.ack_delay_time,
+ acked_packet.receive_timestamp);
}
const bool acked_new_packet = !packets_acked_.empty();
PostProcessNewlyAckedPackets(last_ack_frame_, ack_receive_time, rtt_updated_,
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index 3df874d..787bf8d 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -481,7 +481,8 @@
// |info| due to receipt by the peer.
void MarkPacketHandled(QuicPacketNumber packet_number,
QuicTransmissionInfo* info,
- QuicTime::Delta ack_delay_time);
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp);
// Request that |packet_number| be retransmitted after the other pending
// retransmissions. Does not add it to the retransmissions if it's already
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index c508cca..a0746fe 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -110,7 +110,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 {}
@@ -469,7 +469,7 @@
VerifyRetransmittablePackets(nullptr, 0);
if (manager_.session_decides_what_to_write()) {
// 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());
@@ -623,7 +623,7 @@
SendDataPacket(4);
if (manager_.session_decides_what_to_write()) {
// No new data gets acked in packet 3.
- EXPECT_CALL(notifier_, OnFrameAcked(_, _))
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _))
.WillOnce(Return(false))
.WillRepeatedly(Return(true));
}
@@ -727,7 +727,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));
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 89e08ef..9707c34 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -1582,9 +1582,10 @@
}
bool QuicSession::OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta ack_delay_time) {
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) {
if (frame.type == MESSAGE_FRAME) {
- OnMessageAcked(frame.message_frame->message_id);
+ OnMessageAcked(frame.message_frame->message_id, receive_timestamp);
return true;
}
if (frame.type == CRYPTO_FRAME) {
@@ -1839,7 +1840,8 @@
return {result, 0};
}
-void QuicSession::OnMessageAcked(QuicMessageId message_id) {
+void QuicSession::OnMessageAcked(QuicMessageId message_id,
+ QuicTime receive_timestamp) {
QUIC_DVLOG(1) << ENDPOINT << "message " << message_id << " gets acked.";
}
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 5988369..32dd680 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -142,7 +142,8 @@
// SessionNotifierInterface methods:
bool OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta ack_delay_time) override;
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) override;
void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override;
void OnFrameLost(const QuicFrame& frame) override;
void RetransmitFrames(const QuicFrames& frames,
@@ -189,7 +190,8 @@
MessageResult SendMessage(QuicMemSliceSpan message);
// Called when message with |message_id| gets acked.
- virtual void OnMessageAcked(QuicMessageId message_id);
+ virtual void OnMessageAcked(QuicMessageId message_id,
+ QuicTime receive_timestamp);
// Called when message with |message_id| is considered as lost.
virtual void OnMessageLost(QuicMessageId message_id);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 4e3228e..c8a0a02 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -2209,7 +2209,7 @@
EXPECT_FALSE(session_.IsFrameOutstanding(QuicFrame(&frame2)));
// message 1 gets acked.
- session_.OnMessageAcked(1);
+ session_.OnMessageAcked(1, QuicTime::Zero());
EXPECT_FALSE(session_.IsFrameOutstanding(QuicFrame(&frame)));
}
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index 1a0b1af..5b3de44 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -407,13 +407,14 @@
}
bool QuicUnackedPacketMap::NotifyFramesAcked(const QuicTransmissionInfo& info,
- QuicTime::Delta ack_delay) {
+ QuicTime::Delta ack_delay,
+ QuicTime receive_timestamp) {
if (session_notifier_ == nullptr) {
return false;
}
bool new_data_acked = false;
for (const QuicFrame& frame : info.retransmittable_frames) {
- if (session_notifier_->OnFrameAcked(frame, ack_delay)) {
+ if (session_notifier_->OnFrameAcked(frame, ack_delay, receive_timestamp)) {
new_data_acked = true;
}
}
@@ -436,7 +437,8 @@
void QuicUnackedPacketMap::MaybeAggregateAckedStreamFrame(
const QuicTransmissionInfo& info,
- QuicTime::Delta ack_delay) {
+ QuicTime::Delta ack_delay,
+ QuicTime receive_timestamp) {
if (session_notifier_ == nullptr) {
return;
}
@@ -468,7 +470,7 @@
NotifyAggregatedStreamFrameAcked(ack_delay);
if (frame.type != STREAM_FRAME || frame.stream_frame.fin) {
- session_notifier_->OnFrameAcked(frame, ack_delay);
+ session_notifier_->OnFrameAcked(frame, ack_delay, receive_timestamp);
continue;
}
@@ -488,8 +490,11 @@
// 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.
session_notifier_->OnFrameAcked(QuicFrame(aggregated_stream_frame_),
- ack_delay);
+ ack_delay,
+ /*receive_timestamp=*/QuicTime::Zero());
// Clear aggregated stream frame.
aggregated_stream_frame_.stream_id = -1;
}
diff --git a/quic/core/quic_unacked_packet_map.h b/quic/core/quic_unacked_packet_map.h
index 1a37a1f..17589dd 100644
--- a/quic/core/quic_unacked_packet_map.h
+++ b/quic/core/quic_unacked_packet_map.h
@@ -50,7 +50,8 @@
// Notifies session_notifier that frames have been acked. Returns true if any
// new data gets acked, returns false otherwise.
bool NotifyFramesAcked(const QuicTransmissionInfo& info,
- QuicTime::Delta ack_delay);
+ QuicTime::Delta ack_delay,
+ QuicTime receive_timestamp);
// Notifies session_notifier that frames in |info| are considered as lost.
void NotifyFramesLost(const QuicTransmissionInfo& info,
@@ -179,7 +180,8 @@
// frames or control frames, notify the session notifier they get acked
// immediately.
void MaybeAggregateAckedStreamFrame(const QuicTransmissionInfo& info,
- QuicTime::Delta ack_delay);
+ QuicTime::Delta ack_delay,
+ QuicTime receive_timestamp);
// Notify the session notifier of any stream data aggregated in
// aggregated_stream_frame_. No effect if the stream frame has an invalid
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index 331a0e8..ff26542 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -551,7 +551,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());
QuicTransmissionInfo info1;
@@ -571,20 +571,20 @@
info4.retransmittable_frames.push_back(QuicFrame(stream_frame4));
// Verify stream frames are aggregated.
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(0);
- unacked_packets_.MaybeAggregateAckedStreamFrame(info1,
- QuicTime::Delta::Zero());
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(0);
- unacked_packets_.MaybeAggregateAckedStreamFrame(info2,
- QuicTime::Delta::Zero());
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(0);
- unacked_packets_.MaybeAggregateAckedStreamFrame(info3,
- QuicTime::Delta::Zero());
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(
+ info1, QuicTime::Delta::Zero(), QuicTime::Zero());
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(
+ info2, QuicTime::Delta::Zero(), QuicTime::Zero());
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(
+ info3, QuicTime::Delta::Zero(), QuicTime::Zero());
// Verify aggregated stream frame gets acked since fin is acked.
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(1);
- unacked_packets_.MaybeAggregateAckedStreamFrame(info4,
- QuicTime::Delta::Zero());
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(1);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(
+ info4, QuicTime::Delta::Zero(), QuicTime::Zero());
}
// Regression test for b/112930090.
@@ -614,17 +614,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(
- info, QuicTime::Delta::Zero());
+ info, QuicTime::Delta::Zero(), QuicTime::Zero());
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(
- info, QuicTime::Delta::Zero());
+ info, QuicTime::Delta::Zero(), QuicTime::Zero());
aggregated_data_length = acked_stream_length;
testing::Mock::VerifyAndClearExpectations(¬ifier_);
}
@@ -637,9 +637,9 @@
QuicTransmissionInfo info;
QuicStreamFrame stream_frame(stream_id, true, offset, acked_stream_length);
info.retransmittable_frames.push_back(QuicFrame(stream_frame));
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(1);
- unacked_packets_.MaybeAggregateAckedStreamFrame(info,
- QuicTime::Delta::Zero());
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(1);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(
+ info, QuicTime::Delta::Zero(), QuicTime::Zero());
testing::Mock::VerifyAndClearExpectations(¬ifier_);
}
}
@@ -662,15 +662,15 @@
info2.retransmittable_frames.push_back(QuicFrame(&go_away));
// Verify 2 contiguous stream frames are aggregated.
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(1);
- unacked_packets_.MaybeAggregateAckedStreamFrame(info1,
- QuicTime::Delta::Zero());
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(1);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(
+ info1, QuicTime::Delta::Zero(), QuicTime::Zero());
// Verify aggregated stream frame gets acked.
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(3);
- unacked_packets_.MaybeAggregateAckedStreamFrame(info2,
- QuicTime::Delta::Zero());
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(3);
+ unacked_packets_.MaybeAggregateAckedStreamFrame(
+ info2, QuicTime::Delta::Zero(), QuicTime::Zero());
- EXPECT_CALL(notifier_, OnFrameAcked(_, _)).Times(0);
+ EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).Times(0);
unacked_packets_.NotifyAggregatedStreamFrameAcked(QuicTime::Delta::Zero());
}
diff --git a/quic/core/session_notifier_interface.h b/quic/core/session_notifier_interface.h
index 83fc0f1..a601c3e 100644
--- a/quic/core/session_notifier_interface.h
+++ b/quic/core/session_notifier_interface.h
@@ -19,7 +19,8 @@
// Called when |frame| is acked. Returns true if any new data gets acked,
// returns false otherwise.
virtual bool OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta ack_delay_time) = 0;
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) = 0;
// Called when |frame| is retransmitted.
virtual void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) = 0;
diff --git a/quic/quartc/quartc_session.cc b/quic/quartc/quartc_session.cc
index 2e6729c..95c7e86 100644
--- a/quic/quartc/quartc_session.cc
+++ b/quic/quartc/quartc_session.cc
@@ -246,7 +246,8 @@
session_delegate_->OnMessageReceived(message);
}
-void QuartcSession::OnMessageAcked(QuicMessageId message_id) {
+void QuartcSession::OnMessageAcked(QuicMessageId message_id,
+ QuicTime receive_timestamp) {
auto element = message_to_datagram_id_.find(message_id);
if (element == message_to_datagram_id_.end()) {
@@ -255,6 +256,7 @@
return;
}
+ // TODO(mellem): Pass receive_timestamp to |delegate_|.
session_delegate_->OnMessageAcked(/*datagram_id=*/element->second);
// Free up space -- we should never see message_id again.
diff --git a/quic/quartc/quartc_session.h b/quic/quartc/quartc_session.h
index 042827b..cd8d2cb 100644
--- a/quic/quartc/quartc_session.h
+++ b/quic/quartc/quartc_session.h
@@ -176,7 +176,8 @@
void OnMessageReceived(QuicStringPiece message) override;
// Called when message with |message_id| gets acked.
- void OnMessageAcked(QuicMessageId message_id) override;
+ void OnMessageAcked(QuicMessageId message_id,
+ QuicTime receive_timestamp) override;
// Returns number of queued (not sent) messages submitted by
// SendOrQueueMessage. Messages are queued if connection is congestion
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index bf8edcf..8f1cb7a 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -1054,7 +1054,7 @@
MockSessionNotifier();
~MockSessionNotifier() override;
- MOCK_METHOD2(OnFrameAcked, bool(const QuicFrame&, QuicTime::Delta));
+ MOCK_METHOD3(OnFrameAcked, bool(const QuicFrame&, QuicTime::Delta, QuicTime));
MOCK_METHOD1(OnStreamFrameRetransmitted, void(const QuicStreamFrame&));
MOCK_METHOD1(OnFrameLost, void(const QuicFrame&));
MOCK_METHOD2(RetransmitFrames,
diff --git a/quic/test_tools/simple_session_notifier.cc b/quic/test_tools/simple_session_notifier.cc
index e72e0e1..c6e3801 100644
--- a/quic/test_tools/simple_session_notifier.cc
+++ b/quic/test_tools/simple_session_notifier.cc
@@ -135,7 +135,8 @@
QuicStreamFrame stream_frame(
QuicUtils::GetCryptoStreamId(connection_->transport_version()), false,
interval.min(), interval.max() - interval.min());
- OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero());
+ OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
}
}
@@ -202,7 +203,8 @@
}
bool SimpleSessionNotifier::OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta /*ack_delay_time*/) {
+ QuicTime::Delta /*ack_delay_time*/,
+ QuicTime /*receive_timestamp*/) {
QUIC_DVLOG(1) << "Acking " << frame;
if (frame.type == CRYPTO_FRAME) {
StreamState* state = &crypto_state_[frame.crypto_frame->level];
diff --git a/quic/test_tools/simple_session_notifier.h b/quic/test_tools/simple_session_notifier.h
index e7d4fdc..25c9941 100644
--- a/quic/test_tools/simple_session_notifier.h
+++ b/quic/test_tools/simple_session_notifier.h
@@ -65,7 +65,8 @@
// SessionNotifierInterface methods:
bool OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta ack_delay_time) override;
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) override;
void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override {}
void OnFrameLost(const QuicFrame& frame) override;
void RetransmitFrames(const QuicFrames& frames,
diff --git a/quic/test_tools/simple_session_notifier_test.cc b/quic/test_tools/simple_session_notifier_test.cc
index d2aad9f..d9958c8 100644
--- a/quic/test_tools/simple_session_notifier_test.cc
+++ b/quic/test_tools/simple_session_notifier_test.cc
@@ -154,7 +154,8 @@
QuicStreamFrame stream_frame(
QuicUtils::GetCryptoStreamId(connection_.transport_version()), false,
1024, 1024);
- notifier_.OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero());
+ notifier_.OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
EXPECT_TRUE(notifier_.StreamIsWaitingForAcks(
QuicUtils::GetCryptoStreamId(connection_.transport_version())));
// Neuters unencrypted data.
@@ -315,8 +316,10 @@
// Ack stream 3 [3, 7), and stream 5 [8, 10).
QuicStreamFrame ack_frame1(3, false, 3, 4);
QuicStreamFrame ack_frame2(5, false, 8, 2);
- notifier_.OnFrameAcked(QuicFrame(ack_frame1), QuicTime::Delta::Zero());
- notifier_.OnFrameAcked(QuicFrame(ack_frame2), QuicTime::Delta::Zero());
+ notifier_.OnFrameAcked(QuicFrame(ack_frame1), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
+ notifier_.OnFrameAcked(QuicFrame(ack_frame2), QuicTime::Delta::Zero(),
+ QuicTime::Zero());
EXPECT_FALSE(notifier_.WillingToWrite());
// Force to send.
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index 043eae9..78cc302 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -265,9 +265,10 @@
}
bool QuicEndpoint::OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta ack_delay_time) {
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) {
if (notifier_ != nullptr) {
- return notifier_->OnFrameAcked(frame, ack_delay_time);
+ return notifier_->OnFrameAcked(frame, ack_delay_time, receive_timestamp);
}
return false;
}
diff --git a/quic/test_tools/simulator/quic_endpoint.h b/quic/test_tools/simulator/quic_endpoint.h
index 8bbdbd7..8efef0e 100644
--- a/quic/test_tools/simulator/quic_endpoint.h
+++ b/quic/test_tools/simulator/quic_endpoint.h
@@ -122,7 +122,8 @@
// Begin SessionNotifierInterface methods:
bool OnFrameAcked(const QuicFrame& frame,
- QuicTime::Delta ack_delay_time) override;
+ QuicTime::Delta ack_delay_time,
+ QuicTime receive_timestamp) override;
void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override {}
void OnFrameLost(const QuicFrame& frame) override;
void RetransmitFrames(const QuicFrames& frames,
