Add a kAFFE client option to enable the usage of AckFrequencyFrame, including
(1) Send min_ack_delay from client.
(2) Update client upon receiving AckFrequencyFrame.
Separate options will enable actual sending of AckFrequencyFrame and is in follow-up CLs.
PiperOrigin-RevId: 332049097
Change-Id: Ibc267ab580ce7ed5638fd2ad62226f67c1604a85
diff --git a/quic/core/crypto/crypto_protocol.h b/quic/core/crypto/crypto_protocol.h
index 80273f0..07f2bae 100644
--- a/quic/core/crypto/crypto_protocol.h
+++ b/quic/core/crypto/crypto_protocol.h
@@ -159,6 +159,7 @@
// received before acking
const QuicTag kACKQ = TAG('A', 'C', 'K', 'Q'); // Send an immediate ack after
// 1 RTT of not receiving.
+const QuicTag kAFFE = TAG('A', 'F', 'F', 'E'); // AckFrequencyFrame Enabled.
const QuicTag kSSLR = TAG('S', 'S', 'L', 'R'); // Slow Start Large Reduction.
const QuicTag kNPRR = TAG('N', 'P', 'R', 'R'); // Pace at unity instead of PRR
const QuicTag k2RTO = TAG('2', 'R', 'T', 'O'); // Close connection on 2 RTOs
diff --git a/quic/core/frames/quic_ack_frequency_frame.cc b/quic/core/frames/quic_ack_frequency_frame.cc
index b8c7efa..1486327 100644
--- a/quic/core/frames/quic_ack_frequency_frame.cc
+++ b/quic/core/frames/quic_ack_frequency_frame.cc
@@ -8,6 +8,16 @@
namespace quic {
+QuicAckFrequencyFrame::QuicAckFrequencyFrame(
+ QuicControlFrameId control_frame_id,
+ uint64_t sequence_number,
+ uint64_t packet_tolerance,
+ QuicTime::Delta max_ack_delay)
+ : control_frame_id(control_frame_id),
+ sequence_number(sequence_number),
+ packet_tolerance(packet_tolerance),
+ max_ack_delay(max_ack_delay) {}
+
std::ostream& operator<<(std::ostream& os, const QuicAckFrequencyFrame& frame) {
os << "{ control_frame_id: " << frame.control_frame_id
<< ", sequence_number: " << frame.sequence_number
diff --git a/quic/core/frames/quic_ack_frequency_frame.h b/quic/core/frames/quic_ack_frequency_frame.h
index 52b70da..3f9397c 100644
--- a/quic/core/frames/quic_ack_frequency_frame.h
+++ b/quic/core/frames/quic_ack_frequency_frame.h
@@ -21,8 +21,14 @@
std::ostream& os,
const QuicAckFrequencyFrame& ack_frequency_frame);
- // A unique identifier of this control frame. 0 when this frame is received,
- // and non-zero when sent.
+ QuicAckFrequencyFrame() = default;
+ QuicAckFrequencyFrame(QuicControlFrameId control_frame_id,
+ uint64_t sequence_number,
+ uint64_t packet_tolerance,
+ QuicTime::Delta max_ack_delay);
+
+ // A unique identifier of this control frame. 0 when this frame is
+ // received, and non-zero when sent.
QuicControlFrameId control_frame_id = kInvalidControlFrameId;
// If true, do not ack immediately upon observeation of packet reordering.
@@ -34,10 +40,11 @@
// The maximum number of ack-eliciting packets after which the receiver sends
// an acknowledgement. Invald if == 0.
- uint64_t packet_tolerance = 0;
+ uint64_t packet_tolerance = 2;
// The maximum time that ack packets can be delayed.
- QuicTime::Delta max_ack_delay = QuicTime::Delta::Zero();
+ QuicTime::Delta max_ack_delay =
+ QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
};
} // namespace quic
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 23597e2..89a76af 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -1326,6 +1326,7 @@
*error_details = "MinAckDelay is greater than MaxAckDelay.";
return IETF_QUIC_PROTOCOL_VIOLATION;
}
+ QUIC_RELOADABLE_FLAG_COUNT(quic_record_received_min_ack_delay);
min_ack_delay_ms_.SetReceivedValue(params.min_ack_delay_us.value() /
kNumMicrosPerMilli);
}
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index fc72c59..bae994f 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -1708,13 +1708,24 @@
return connected_;
}
-bool QuicConnection::OnAckFrequencyFrame(
- const QuicAckFrequencyFrame& /*frame*/) {
+bool QuicConnection::OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) {
UpdatePacketContent(ACK_FREQUENCY_FRAME);
- // TODO(b/148614353): implement this fully.
- QUIC_LOG_EVERY_N_SEC(ERROR, 120) << "Get unexpected AckFrequencyFrame.";
- return false;
+ if (!can_receive_ack_frequency_frame_) {
+ QUIC_LOG_EVERY_N_SEC(ERROR, 120) << "Get unexpected AckFrequencyFrame.";
+ return false;
+ }
+ if (auto packet_number_space =
+ QuicUtils::GetPacketNumberSpace(last_decrypted_packet_level_) ==
+ APPLICATION_DATA) {
+ uber_received_packet_manager_.OnAckFrequencyFrame(frame);
+ } else {
+ QUIC_LOG_EVERY_N_SEC(ERROR, 120)
+ << "Get AckFrequencyFrame in packet number space "
+ << packet_number_space;
+ }
+ return true;
}
+
bool QuicConnection::OnBlockedFrame(const QuicBlockedFrame& frame) {
DCHECK(connected_);
@@ -4800,11 +4811,6 @@
new_value);
}
-void QuicConnection::set_ack_frequency(size_t new_value) {
- DCHECK_GT(new_value, 0u);
- uber_received_packet_manager_.set_ack_frequency(new_value);
-}
-
const QuicAckFrame& QuicConnection::ack_frame() const {
if (SupportsMultiplePacketNumberSpaces()) {
return uber_received_packet_manager_.GetAckFrame(
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index dcd655b..5461908 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -925,8 +925,6 @@
size_t min_received_before_ack_decimation() const;
void set_min_received_before_ack_decimation(size_t new_value);
- void set_ack_frequency(size_t new_value);
-
// If |defer| is true, configures the connection to defer sending packets in
// response to an ACK to the SendAlarm. If |defer| is false, packets may be
// sent immediately after receiving an ACK.
@@ -1030,6 +1028,14 @@
// false.
bool MaybeTestLiveness();
+ bool can_receive_ack_frequency_frame() const {
+ return can_receive_ack_frequency_frame_;
+ }
+
+ void set_can_receive_ack_frequency_frame() {
+ can_receive_ack_frequency_frame_ = true;
+ }
+
protected:
// Calls cancel() on all the alarms owned by this connection.
void CancelAllAlarms();
@@ -1770,6 +1776,8 @@
// --gfe2_reloadable_flag_quic_start_peer_migration_earlier.
bool send_path_response_ = start_peer_migration_earlier_ &&
GetQuicReloadableFlag(quic_send_path_response);
+ // True if AckFrequencyFrame is supported.
+ bool can_receive_ack_frequency_frame_ = false;
};
} // namespace quic
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index fdc4d7a..940a988 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -2976,12 +2976,20 @@
ProcessAckPacket(&frame2);
}
-TEST_P(QuicConnectionTest, AckSentEveryNthPacket) {
- connection_.set_ack_frequency(3);
+TEST_P(QuicConnectionTest, AckFrequencyUpdatedFromAckFrequencyFrame) {
+ if (!GetParam().version.HasIetfQuicFrames()) {
+ return;
+ }
+
+ QuicAckFrequencyFrame frame;
+ frame.packet_tolerance = 3;
+
+ connection_.set_can_receive_ack_frequency_frame();
+ connection_.OnDecryptedPacket(ENCRYPTION_FORWARD_SECURE);
+ connection_.OnAckFrequencyFrame(frame);
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(39);
-
// Expect 13 acks, every 3rd packet.
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(13);
// Receives packets 1 - 39.
@@ -2990,6 +2998,29 @@
}
}
+TEST_P(QuicConnectionTest,
+ AckFrequencyFrameOutsideApplicationDataNumberSpaceIsIgnored) {
+ if (!GetParam().version.HasIetfQuicFrames()) {
+ return;
+ }
+
+ QuicAckFrequencyFrame frame;
+ frame.packet_tolerance = 3;
+ connection_.set_can_receive_ack_frequency_frame();
+ connection_.OnDecryptedPacket(ENCRYPTION_HANDSHAKE);
+ connection_.OnAckFrequencyFrame(frame);
+ connection_.OnDecryptedPacket(ENCRYPTION_FORWARD_SECURE);
+
+ EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+ EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(60);
+ // Expect 30 acks, every 2nd (instead of 3rd) packet.
+ EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(30);
+ // Receives packets 1 - 60.
+ for (size_t i = 1; i <= 60; ++i) {
+ ProcessDataPacket(i);
+ }
+}
+
TEST_P(QuicConnectionTest, AckDecimationReducesAcks) {
const size_t kMinRttMs = 40;
RttStats* rtt_stats = const_cast<RttStats*>(manager_->GetRttStats());
diff --git a/quic/core/quic_received_packet_manager.cc b/quic/core/quic_received_packet_manager.cc
index 1c9218a..9a84d97 100644
--- a/quic/core/quic_received_packet_manager.cc
+++ b/quic/core/quic_received_packet_manager.cc
@@ -47,11 +47,13 @@
ack_decimation_delay_(kAckDecimationDelay),
unlimited_ack_decimation_(false),
one_immediate_ack_(false),
+ ignore_order_(false),
local_max_ack_delay_(
QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs)),
ack_timeout_(QuicTime::Zero()),
time_of_previous_received_packet_(QuicTime::Zero()),
- was_last_packet_missing_(false) {}
+ was_last_packet_missing_(false),
+ last_ack_frequency_frame_sequence_number_(-1) {}
QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
@@ -194,8 +196,9 @@
QuicTime::Delta QuicReceivedPacketManager::GetMaxAckDelay(
QuicPacketNumber last_received_packet_number,
const RttStats& rtt_stats) const {
- if (last_received_packet_number <
- PeerFirstSendingPacketNumber() + min_received_before_ack_decimation_) {
+ if (AckFrequencyFrameReceived() ||
+ last_received_packet_number < PeerFirstSendingPacketNumber() +
+ min_received_before_ack_decimation_) {
return local_max_ack_delay_;
}
@@ -212,6 +215,11 @@
void QuicReceivedPacketManager::MaybeUpdateAckFrequency(
QuicPacketNumber last_received_packet_number) {
+ if (AckFrequencyFrameReceived()) {
+ // Skip Ack Decimation below after receiving an AckFrequencyFrame from the
+ // other end point.
+ return;
+ }
if (last_received_packet_number <
PeerFirstSendingPacketNumber() + min_received_before_ack_decimation_) {
return;
@@ -231,7 +239,8 @@
return;
}
- if (was_last_packet_missing_ && last_sent_largest_acked_.IsInitialized() &&
+ if (!ignore_order_ && was_last_packet_missing_ &&
+ last_sent_largest_acked_.IsInitialized() &&
last_received_packet_number < last_sent_largest_acked_) {
// Only ack immediately if an ACK frame was sent with a larger largest acked
// than the newly received packet number.
@@ -252,7 +261,7 @@
return;
}
- if (HasNewMissingPackets()) {
+ if (!ignore_order_ && HasNewMissingPackets()) {
ack_timeout_ = now;
return;
}
@@ -314,4 +323,17 @@
return ack_frame_.packets.Empty();
}
+void QuicReceivedPacketManager::OnAckFrequencyFrame(
+ const QuicAckFrequencyFrame& frame) {
+ int64_t new_sequence_number = frame.sequence_number;
+ if (new_sequence_number <= last_ack_frequency_frame_sequence_number_) {
+ // Ignore old ACK_FREQUENCY frames.
+ return;
+ }
+ last_ack_frequency_frame_sequence_number_ = new_sequence_number;
+ ack_frequency_ = frame.packet_tolerance;
+ local_max_ack_delay_ = frame.max_ack_delay;
+ ignore_order_ = frame.ignore_order;
+}
+
} // namespace quic
diff --git a/quic/core/quic_received_packet_manager.h b/quic/core/quic_received_packet_manager.h
index c8b55c4..78ed411 100644
--- a/quic/core/quic_received_packet_manager.h
+++ b/quic/core/quic_received_packet_manager.h
@@ -5,6 +5,8 @@
#ifndef QUICHE_QUIC_CORE_QUIC_RECEIVED_PACKET_MANAGER_H_
#define QUICHE_QUIC_CORE_QUIC_RECEIVED_PACKET_MANAGER_H_
+#include <cstddef>
+#include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_config.h"
#include "net/third_party/quiche/src/quic/core/quic_framer.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
@@ -123,6 +125,8 @@
QuicTime ack_timeout() const { return ack_timeout_; }
+ void OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame);
+
private:
friend class test::QuicConnectionPeer;
friend class test::QuicReceivedPacketManagerPeer;
@@ -137,6 +141,10 @@
QuicTime::Delta GetMaxAckDelay(QuicPacketNumber last_received_packet_number,
const RttStats& rtt_stats) const;
+ bool AckFrequencyFrameReceived() const {
+ return last_ack_frequency_frame_sequence_number_ >= 0;
+ }
+
// Least packet number of the the packet sent by the peer for which it
// hasn't received an ack.
QuicPacketNumber peer_least_packet_awaiting_ack_;
@@ -177,6 +185,8 @@
bool unlimited_ack_decimation_;
// When true, only send 1 immediate ACK when reordering is detected.
bool one_immediate_ack_;
+ // When true, do not ack immediately upon observation of packet reordering.
+ bool ignore_order_;
// The local node's maximum ack delay time. This is the maximum amount of
// time to wait before sending an acknowledgement.
@@ -192,6 +202,10 @@
// Last sent largest acked, which gets updated when ACK was successfully sent.
QuicPacketNumber last_sent_largest_acked_;
+
+ // The sequence number of the last received AckFrequencyFrame. Negative if
+ // none received.
+ int64_t last_ack_frequency_frame_sequence_number_;
};
} // namespace quic
diff --git a/quic/core/quic_received_packet_manager_test.cc b/quic/core/quic_received_packet_manager_test.cc
index 2cf8227..c8d1638 100644
--- a/quic/core/quic_received_packet_manager_test.cc
+++ b/quic/core/quic_received_packet_manager_test.cc
@@ -5,6 +5,7 @@
#include "net/third_party/quiche/src/quic/core/quic_received_packet_manager.h"
#include <algorithm>
+#include <cstddef>
#include <ostream>
#include <vector>
@@ -532,6 +533,125 @@
CheckAckTimeout(clock_.ApproximateNow());
}
+TEST_F(QuicReceivedPacketManagerTest,
+ UpdateMaxAckDelayAndAckFrequencyFromAckFrequencyFrame) {
+ EXPECT_FALSE(HasPendingAck());
+
+ QuicAckFrequencyFrame frame;
+ frame.max_ack_delay = QuicTime::Delta::FromMilliseconds(10);
+ frame.packet_tolerance = 5;
+ received_manager_.OnAckFrequencyFrame(frame);
+
+ for (int i = 1; i <= 50; ++i) {
+ RecordPacketReceipt(i, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, i);
+ if (i % frame.packet_tolerance == 0) {
+ CheckAckTimeout(clock_.ApproximateNow());
+ } else {
+ CheckAckTimeout(clock_.ApproximateNow() + frame.max_ack_delay);
+ }
+ }
+}
+
+TEST_F(QuicReceivedPacketManagerTest,
+ DisableOutOfOrderAckByIgnoreOrderFromAckFrequencyFrame) {
+ EXPECT_FALSE(HasPendingAck());
+
+ QuicAckFrequencyFrame frame;
+ frame.max_ack_delay = kDelayedAckTime;
+ frame.packet_tolerance = 2;
+ frame.ignore_order = true;
+ received_manager_.OnAckFrequencyFrame(frame);
+
+ RecordPacketReceipt(4, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 4);
+ CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
+ RecordPacketReceipt(5, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 5);
+ // Immediate ack is sent as this is the 2nd packet of every two packets.
+ CheckAckTimeout(clock_.ApproximateNow());
+
+ RecordPacketReceipt(3, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 3);
+ // Don't ack as ignore_order is set by AckFrequencyFrame.
+ CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
+
+ RecordPacketReceipt(2, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 2);
+ // Immediate ack is sent as this is the 2nd packet of every two packets.
+ CheckAckTimeout(clock_.ApproximateNow());
+
+ RecordPacketReceipt(1, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 1);
+ // Don't ack as ignore_order is set by AckFrequencyFrame.
+ CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
+}
+
+TEST_F(QuicReceivedPacketManagerTest,
+ DisableMissingPaketsAckByIgnoreOrderFromAckFrequencyFrame) {
+ EXPECT_FALSE(HasPendingAck());
+ QuicConfig config;
+ config.SetConnectionOptionsToSend({kAFFE});
+ received_manager_.SetFromConfig(config, Perspective::IS_CLIENT);
+
+ QuicAckFrequencyFrame frame;
+ frame.max_ack_delay = kDelayedAckTime;
+ frame.packet_tolerance = 2;
+ frame.ignore_order = true;
+ received_manager_.OnAckFrequencyFrame(frame);
+
+ RecordPacketReceipt(1, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 1);
+ CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
+ RecordPacketReceipt(2, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 2);
+ // Immediate ack is sent as this is the 2nd packet of every two packets.
+ CheckAckTimeout(clock_.ApproximateNow());
+
+ RecordPacketReceipt(4, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 4);
+ // Don't ack even if packet 3 is newly missing as ignore_order is set by
+ // AckFrequencyFrame.
+ CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
+
+ RecordPacketReceipt(5, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 5);
+ // Immediate ack is sent as this is the 2nd packet of every two packets.
+ CheckAckTimeout(clock_.ApproximateNow());
+
+ RecordPacketReceipt(7, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, 7);
+ // Don't ack even if packet 6 is newly missing as ignore_order is set by
+ // AckFrequencyFrame.
+ CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
+}
+
+TEST_F(QuicReceivedPacketManagerTest,
+ AckDecimationDisabledWhenAckFrequencyFrameIsReceived) {
+ EXPECT_FALSE(HasPendingAck());
+
+ QuicAckFrequencyFrame frame;
+ frame.max_ack_delay = kDelayedAckTime;
+ frame.packet_tolerance = 3;
+ frame.ignore_order = true;
+ received_manager_.OnAckFrequencyFrame(frame);
+
+ // Process all the packets in order so there aren't missing packets.
+ uint64_t kFirstDecimatedPacket = 101;
+ uint64_t FiftyPacketsAfterAckDecimation = kFirstDecimatedPacket + 50;
+ for (uint64_t i = 1; i < FiftyPacketsAfterAckDecimation; ++i) {
+ RecordPacketReceipt(i, clock_.ApproximateNow());
+ MaybeUpdateAckTimeout(kInstigateAck, i);
+ if (i % 3 == 0) {
+ // Ack every 3 packets as decimation is disabled.
+ CheckAckTimeout(clock_.ApproximateNow());
+ } else {
+ // Ack at default delay as decimation is disabled.
+ CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
+ }
+ }
+}
+
} // namespace
} // namespace test
} // namespace quic
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index da9a925..e3c389b 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -122,6 +122,12 @@
connection_->SetSessionNotifier(this);
connection_->SetDataProducer(this);
connection_->SetFromConfig(config_);
+ if (perspective_ == Perspective::IS_CLIENT &&
+ config_.HasClientRequestedIndependentOption(kAFFE, perspective_) &&
+ version().HasIetfQuicFrames()) {
+ connection_->set_can_receive_ack_frequency_frame();
+ config_.SetMinAckDelayMs(kDefaultMinAckDelayTimeMs);
+ }
if (perspective() == Perspective::IS_CLIENT && version().UsesTls() &&
!version().HasHandshakeDone()) {
config_.SetSupportHandshakeDone();
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 909a9f1..fad4082 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -2219,6 +2219,17 @@
session_.OnStreamFrame(frame);
}
+TEST_P(QuicSessionTestClient, MinAckDelaySetOnTheClientQuicConfig) {
+ if (!session_.version().HasIetfQuicFrames()) {
+ return;
+ }
+ session_.config()->SetClientConnectionOptions({kAFFE});
+ session_.Initialize();
+ ASSERT_EQ(session_.config()->GetMinAckDelayToSendMs(),
+ kDefaultMinAckDelayTimeMs);
+ ASSERT_TRUE(session_.connection()->can_receive_ack_frequency_frame());
+}
+
TEST_P(QuicSessionTestClient, FailedToCreateStreamIfTooCloseToIdleTimeout) {
connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
EXPECT_TRUE(session_.CanOpenNextOutgoingBidirectionalStream());
diff --git a/quic/core/uber_received_packet_manager.cc b/quic/core/uber_received_packet_manager.cc
index d672fb8..7b2b32f 100644
--- a/quic/core/uber_received_packet_manager.cc
+++ b/quic/core/uber_received_packet_manager.cc
@@ -214,20 +214,20 @@
}
}
-void UberReceivedPacketManager::set_max_ack_delay(
- QuicTime::Delta max_ack_delay) {
- if (!supports_multiple_packet_number_spaces_) {
- received_packet_managers_[0].set_local_max_ack_delay(max_ack_delay);
- return;
- }
- received_packet_managers_[APPLICATION_DATA].set_local_max_ack_delay(
- max_ack_delay);
-}
-
void UberReceivedPacketManager::set_save_timestamps(bool save_timestamps) {
for (auto& received_packet_manager : received_packet_managers_) {
received_packet_manager.set_save_timestamps(save_timestamps);
}
}
+void UberReceivedPacketManager::OnAckFrequencyFrame(
+ const QuicAckFrequencyFrame& frame) {
+ if (!supports_multiple_packet_number_spaces_) {
+ QUIC_BUG << "Received AckFrequencyFrame when multiple packet number spaces "
+ "is not supported";
+ return;
+ }
+ received_packet_managers_[APPLICATION_DATA].OnAckFrequencyFrame(frame);
+}
+
} // namespace quic
diff --git a/quic/core/uber_received_packet_manager.h b/quic/core/uber_received_packet_manager.h
index a3c0877..17b5e26 100644
--- a/quic/core/uber_received_packet_manager.h
+++ b/quic/core/uber_received_packet_manager.h
@@ -5,6 +5,7 @@
#ifndef QUICHE_QUIC_CORE_UBER_RECEIVED_PACKET_MANAGER_H_
#define QUICHE_QUIC_CORE_UBER_RECEIVED_PACKET_MANAGER_H_
+#include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_received_packet_manager.h"
namespace quic {
@@ -89,8 +90,7 @@
void set_max_ack_ranges(size_t max_ack_ranges);
- // Set the max ack delay to use for application data.
- void set_max_ack_delay(QuicTime::Delta max_ack_delay);
+ void OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame);
void set_save_timestamps(bool save_timestamps);
diff --git a/quic/core/uber_received_packet_manager_test.cc b/quic/core/uber_received_packet_manager_test.cc
index d4815a2..b7063d2 100644
--- a/quic/core/uber_received_packet_manager_test.cc
+++ b/quic/core/uber_received_packet_manager_test.cc
@@ -332,20 +332,6 @@
CheckAckTimeout(clock_.ApproximateNow());
}
-TEST_F(UberReceivedPacketManagerTest, SendDelayedMaxAckDelay) {
- EXPECT_FALSE(HasPendingAck());
- QuicTime::Delta max_ack_delay = QuicTime::Delta::FromMilliseconds(100);
- manager_->set_max_ack_delay(max_ack_delay);
- QuicTime ack_time = clock_.ApproximateNow() + max_ack_delay;
-
- RecordPacketReceipt(1, clock_.ApproximateNow());
- MaybeUpdateAckTimeout(kInstigateAck, 1);
- CheckAckTimeout(ack_time);
- // Simulate delayed ack alarm firing.
- clock_.AdvanceTime(max_ack_delay);
- CheckAckTimeout(clock_.ApproximateNow());
-}
-
TEST_F(UberReceivedPacketManagerTest, SendDelayedAckDecimation) {
EXPECT_FALSE(HasPendingAck());
// The ack time should be based on min_rtt * 1/4, since it's less than the
