Rename quic::kMaxPacketSize to quic::kMaxOutgoingPacketSize
As part of cl/242197597, QUIC now has separate values for maximum incoming and outgoing packet sizes. This CL renames the constant to be clearer.
gfe-relnote: constant rename, no functional impact
PiperOrigin-RevId: 242708648
Change-Id: I3f440ba44b9c12394026116aaecdd2c166cc63b6
diff --git a/quic/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index 57d8925..cea445d 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -99,7 +99,7 @@
TestDelegate delegate_;
QuicPacketHeader header_;
std::unique_ptr<QuicEncryptedPacket> packet_;
- char buffer_[kMaxPacketSize];
+ char buffer_[kMaxOutgoingPacketSize];
};
TEST_F(ChloExtractorTest, FindsValidChlo) {
diff --git a/quic/core/congestion_control/bbr_sender.cc b/quic/core/congestion_control/bbr_sender.cc
index 9de79cd..1c0d274 100644
--- a/quic/core/congestion_control/bbr_sender.cc
+++ b/quic/core/congestion_control/bbr_sender.cc
@@ -686,7 +686,7 @@
// we allow an extra packet since QUIC checks CWND before sending a
// packet.
if (unacked_packets_->bytes_in_flight() <
- ProbeRttCongestionWindow() + kMaxPacketSize) {
+ ProbeRttCongestionWindow() + kMaxOutgoingPacketSize) {
exit_probe_rtt_at_ = now + kProbeRttTime;
probe_rtt_round_passed_ = false;
}
diff --git a/quic/core/congestion_control/bbr_sender_test.cc b/quic/core/congestion_control/bbr_sender_test.cc
index b3ed286..3d40e0a 100644
--- a/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quic/core/congestion_control/bbr_sender_test.cc
@@ -63,8 +63,8 @@
const QuicTime::Delta kLocalPropagationDelay =
QuicTime::Delta::FromMilliseconds(2);
const QuicTime::Delta kTestTransferTime =
- kTestLinkBandwidth.TransferTime(kMaxPacketSize) +
- kLocalLinkBandwidth.TransferTime(kMaxPacketSize);
+ kTestLinkBandwidth.TransferTime(kMaxOutgoingPacketSize) +
+ kLocalLinkBandwidth.TransferTime(kMaxOutgoingPacketSize);
const QuicTime::Delta kTestRtt =
(kTestPropagationDelay + kLocalPropagationDelay + kTestTransferTime) * 2;
const QuicByteCount kTestBdp = kTestRtt * kTestLinkBandwidth;
@@ -1091,7 +1091,8 @@
QuicBandwidth pacing_rate = original_pacing_rate;
const QuicByteCount original_cwnd = sender_->GetCongestionWindow();
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(), kMaxOutgoingPacketSize));
QuicPacketNumber largest_sent =
bbr_sender_.connection()->sent_packet_manager().GetLargestSentPacket();
for (QuicPacketNumber packet_number =
@@ -1141,7 +1142,8 @@
QuicBandwidth pacing_rate = original_pacing_rate;
const QuicByteCount original_cwnd = sender_->GetCongestionWindow();
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(), kMaxOutgoingPacketSize));
QuicPacketNumber largest_sent =
bbr_sender_.connection()->sent_packet_manager().GetLargestSentPacket();
for (QuicPacketNumber packet_number =
diff --git a/quic/core/congestion_control/general_loss_algorithm_test.cc b/quic/core/congestion_control/general_loss_algorithm_test.cc
index c6e0145..0172dfc 100644
--- a/quic/core/congestion_control/general_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/general_loss_algorithm_test.cc
@@ -92,20 +92,20 @@
AckedPacketVector packets_acked;
// No loss on one ack.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// No loss on two acks.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(3, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// Loss on three acks.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(4, packets_acked, {1});
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -121,14 +121,14 @@
AckedPacketVector packets_acked;
// Nack the first packet 3 times in a single StretchAck.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(4, packets_acked, {1});
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -143,8 +143,8 @@
AckedPacketVector packets_acked;
// Nack the first packet 3 times in an AckFrame with three missing packets.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(4, packets_acked, {1});
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -158,8 +158,8 @@
AckedPacketVector packets_acked;
// Early retransmit when the final packet gets acked and the first is nacked.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
EXPECT_EQ(clock_.Now() + 1.25 * rtt_stats_.smoothed_rtt(),
@@ -184,7 +184,8 @@
// elapsed since the packets were sent.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(kNumSentPackets));
packets_acked.push_back(AckedPacket(QuicPacketNumber(kNumSentPackets),
- kMaxPacketSize, QuicTime::Zero()));
+ kMaxOutgoingPacketSize,
+ QuicTime::Zero()));
// This simulates a single ack following multiple missing packets with FACK.
VerifyLosses(kNumSentPackets, packets_acked, {1, 2});
packets_acked.clear();
@@ -221,8 +222,8 @@
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
}
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
EXPECT_EQ(clock_.Now() + 0.25 * rtt_stats_.smoothed_rtt(),
loss_algorithm_.GetLossTimeout());
@@ -244,8 +245,8 @@
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
}
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
EXPECT_EQ(clock_.Now() + 0.25 * rtt_stats_.smoothed_rtt(),
@@ -276,8 +277,8 @@
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
}
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, {1});
}
@@ -292,20 +293,20 @@
AckedPacketVector packets_acked;
// No loss on one ack.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// No loss on two acks.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(3, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// Loss on three acks.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(4, packets_acked, {1});
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -323,22 +324,22 @@
AckedPacketVector packets_acked;
// Nack the first packet 3 times in a single StretchAck.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(4, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// The timer isn't set because we expect more acks.
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
// Process another ack and then packet 1 will be lost.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(5));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(5), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(5), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(5, packets_acked, {1});
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -354,16 +355,16 @@
AckedPacketVector packets_acked;
// Nack the first packet 3 times in an AckFrame with three missing packets.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(4, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// The timer isn't set because we expect more acks.
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
// Process another ack and then packet 1 and 2 will be lost.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(5));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(5), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(5), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(5, packets_acked, {1, 2});
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -378,8 +379,8 @@
}
AckedPacketVector packets_acked;
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
for (size_t i = 1; i < 500; ++i) {
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
@@ -406,8 +407,8 @@
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
// The packet should not be lost until 1.25 RTTs pass.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
if (GetQuicReloadableFlag(quic_eighth_rtt_loss_detection)) {
@@ -438,8 +439,8 @@
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
// The packet should not be lost without a nack.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(1), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(1), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(1, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// The timer should still not be set.
@@ -465,8 +466,8 @@
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
// The packet should not be lost until 1.25 RTTs pass.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(10));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(10), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(10), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(10, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
if (GetQuicReloadableFlag(quic_eighth_rtt_loss_detection)) {
@@ -497,8 +498,8 @@
// The packet should not be lost until 1.25 RTTs pass.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(10));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(10), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(10), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(10, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
if (GetQuicReloadableFlag(quic_eighth_rtt_loss_detection)) {
@@ -515,8 +516,8 @@
// are lost.
for (uint64_t i = 1; i <= 9; ++i) {
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(i));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(i), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(i), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(i, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
@@ -538,8 +539,8 @@
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
// Packet 1 should not be lost until 1/16 RTTs pass.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
- packets_acked.push_back(
- AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+ packets_acked.push_back(AckedPacket(
+ QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
packets_acked.clear();
// Expect the timer to be set to 1/16 RTT's in the future.
diff --git a/quic/core/congestion_control/pacing_sender_test.cc b/quic/core/congestion_control/pacing_sender_test.cc
index 3ed881a..ea9debf 100644
--- a/quic/core/congestion_control/pacing_sender_test.cc
+++ b/quic/core/congestion_control/pacing_sender_test.cc
@@ -52,7 +52,8 @@
if (burst_size == 0) {
EXPECT_CALL(*mock_sender_, OnCongestionEvent(_, _, _, _, _));
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
AckedPacketVector empty;
pacing_sender_->OnCongestionEvent(true, 1234, clock_.Now(), empty,
lost_packets);
@@ -84,15 +85,16 @@
}
EXPECT_CALL(*mock_sender_,
OnPacketSent(clock_.Now(), bytes_in_flight, packet_number_,
- kMaxPacketSize, retransmittable_data));
+ kMaxOutgoingPacketSize, retransmittable_data));
EXPECT_CALL(*mock_sender_, GetCongestionWindow())
.Times(AtMost(1))
.WillRepeatedly(Return(cwnd * kDefaultTCPMSS));
- EXPECT_CALL(*mock_sender_, CanSend(bytes_in_flight + kMaxPacketSize))
+ EXPECT_CALL(*mock_sender_,
+ CanSend(bytes_in_flight + kMaxOutgoingPacketSize))
.Times(AtMost(1))
.WillRepeatedly(Return(!cwnd_limited));
pacing_sender_->OnPacketSent(clock_.Now(), bytes_in_flight,
- packet_number_++, kMaxPacketSize,
+ packet_number_++, kMaxOutgoingPacketSize,
retransmittable_data);
}
@@ -151,8 +153,9 @@
TEST_F(PacingSenderTest, VariousSending) {
// Configure pacing rate of 1 packet per 1 ms, no initial burst.
- InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(
+ 0, QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
// Now update the RTT and verify that packets are actually paced.
UpdateRtt();
@@ -206,8 +209,9 @@
TEST_F(PacingSenderTest, InitialBurst) {
// Configure pacing rate of 1 packet per 1 ms.
- InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(
+ 10, QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
// Update the RTT and verify that the first 10 packets aren't paced.
UpdateRtt();
@@ -242,8 +246,9 @@
TEST_F(PacingSenderTest, InitialBurstNoRttMeasurement) {
// Configure pacing rate of 1 packet per 1 ms.
- InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(
+ 10, QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
// Send 10 packets, and verify that they are not paced.
for (int i = 0; i < kInitialBurstPackets; ++i) {
@@ -277,9 +282,9 @@
TEST_F(PacingSenderTest, FastSending) {
// Ensure the pacing sender paces, even when the inter-packet spacing is less
// than the pacing granularity.
- InitPacingRate(10,
- QuicBandwidth::FromBytesAndTimeDelta(
- 2 * kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
+ 2 * kMaxOutgoingPacketSize,
+ QuicTime::Delta::FromMilliseconds(1)));
// Update the RTT and verify that the first 10 packets aren't paced.
UpdateRtt();
@@ -315,18 +320,20 @@
TEST_F(PacingSenderTest, NoBurstEnteringRecovery) {
// Configure pacing rate of 1 packet per 1 ms with no burst tokens.
- InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(
+ 0, QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
// Sending a packet will set burst tokens.
CheckPacketIsSentImmediately();
// Losing a packet will set clear burst tokens.
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
AckedPacketVector empty_acked;
EXPECT_CALL(*mock_sender_,
- OnCongestionEvent(true, kMaxPacketSize, _, IsEmpty(), _));
- pacing_sender_->OnCongestionEvent(true, kMaxPacketSize, clock_.Now(),
+ OnCongestionEvent(true, kMaxOutgoingPacketSize, _, IsEmpty(), _));
+ pacing_sender_->OnCongestionEvent(true, kMaxOutgoingPacketSize, clock_.Now(),
empty_acked, lost_packets);
// One packet is sent immediately, because of 1ms pacing granularity.
CheckPacketIsSentImmediately();
@@ -340,8 +347,9 @@
TEST_F(PacingSenderTest, NoBurstInRecovery) {
// Configure pacing rate of 1 packet per 1 ms with no burst tokens.
- InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(
+ 0, QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
UpdateRtt();
@@ -353,8 +361,9 @@
TEST_F(PacingSenderTest, CwndLimited) {
// Configure pacing rate of 1 packet per 1 ms, no initial burst.
- InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(
+ 0, QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
UpdateRtt();
@@ -382,8 +391,9 @@
SetQuicFlag(&FLAGS_quic_lumpy_pacing_size, 3);
SetQuicFlag(&FLAGS_quic_lumpy_pacing_cwnd_fraction, 0.5f);
// Configure pacing rate of 1 packet per 1 ms.
- InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+ InitPacingRate(
+ 10, QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
UpdateRtt();
// Send 10 packets, and verify that they are not paced.
@@ -438,8 +448,9 @@
// Configure pacing rate of 1 packet per 100 ms.
QuicTime::Delta inter_packet_delay = QuicTime::Delta::FromMilliseconds(100);
- InitPacingRate(kInitialBurstPackets, QuicBandwidth::FromBytesAndTimeDelta(
- kMaxPacketSize, inter_packet_delay));
+ InitPacingRate(kInitialBurstPackets,
+ QuicBandwidth::FromBytesAndTimeDelta(kMaxOutgoingPacketSize,
+ inter_packet_delay));
UpdateRtt();
// Send kInitialBurstPackets packets, and verify that they are not paced.
diff --git a/quic/core/congestion_control/send_algorithm_test.cc b/quic/core/congestion_control/send_algorithm_test.cc
index b2fa2f8..c07508c 100644
--- a/quic/core/congestion_control/send_algorithm_test.cc
+++ b/quic/core/congestion_control/send_algorithm_test.cc
@@ -63,8 +63,8 @@
const QuicTime::Delta kTestLinkWiredPropagationDelay =
QuicTime::Delta::FromMilliseconds(50);
const QuicTime::Delta kTestWiredTransferTime =
- kTestLinkWiredBandwidth.TransferTime(kMaxPacketSize) +
- kLocalLinkBandwidth.TransferTime(kMaxPacketSize);
+ kTestLinkWiredBandwidth.TransferTime(kMaxOutgoingPacketSize) +
+ kLocalLinkBandwidth.TransferTime(kMaxOutgoingPacketSize);
const QuicTime::Delta kTestWiredRtt =
(kTestLinkWiredPropagationDelay + kLocalPropagationDelay +
kTestWiredTransferTime) *
@@ -79,7 +79,7 @@
QuicBandwidth::FromKBitsPerSecond(200);
const QuicTime::Delta kTestLinkLowBdpPropagationDelay =
QuicTime::Delta::FromMilliseconds(50);
-const QuicByteCount kTestPolicerQueue = kMaxPacketSize;
+const QuicByteCount kTestPolicerQueue = kMaxOutgoingPacketSize;
// Satellite network settings. In a satellite network, the bottleneck
// buffer is typically sized for non-satellite links , but the
diff --git a/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quic/core/congestion_control/uber_loss_algorithm_test.cc
index ee61e42..2945214 100644
--- a/quic/core/congestion_control/uber_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -50,8 +50,8 @@
packets_acked_.clear();
for (uint64_t acked : packets_acked) {
unacked_packets_->RemoveFromInFlight(QuicPacketNumber(acked));
- packets_acked_.push_back(AckedPacket(QuicPacketNumber(acked),
- kMaxPacketSize, QuicTime::Zero()));
+ packets_acked_.push_back(AckedPacket(
+ QuicPacketNumber(acked), kMaxOutgoingPacketSize, QuicTime::Zero()));
}
}
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 478e929..88875be 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -910,11 +910,11 @@
return;
}
- char plaintext[kMaxPacketSize];
+ char plaintext[kMaxOutgoingPacketSize];
size_t plaintext_length = 0;
const bool success = crypters.decrypter->DecryptPacket(
0 /* packet number */, QuicStringPiece() /* associated data */,
- cetv_ciphertext, plaintext, &plaintext_length, kMaxPacketSize);
+ cetv_ciphertext, plaintext, &plaintext_length, kMaxOutgoingPacketSize);
if (!success) {
context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
"CETV decryption failure");
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index f225785..60fb22c 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -19,7 +19,7 @@
kInitialMaxDataId = 1,
kInitialMaxBidiStreamsId = 2,
kIdleTimeoutId = 3,
- kMaxPacketSizeId = 5,
+ kMaxOutgoingPacketSizeId = 5,
kStatelessResetTokenId = 6,
kAckDelayExponentId = 7,
kInitialMaxUniStreamsId = 8,
@@ -150,7 +150,7 @@
}
CBB max_packet_size_param;
if (in.max_packet_size.present) {
- if (!CBB_add_u16(¶ms, kMaxPacketSizeId) ||
+ if (!CBB_add_u16(¶ms, kMaxOutgoingPacketSizeId) ||
!CBB_add_u16_length_prefixed(¶ms, &max_packet_size_param) ||
!CBB_add_u16(&max_packet_size_param, in.max_packet_size.value)) {
return false;
@@ -255,7 +255,7 @@
return false;
}
break;
- case kMaxPacketSizeId:
+ case kMaxOutgoingPacketSizeId:
if (!CBS_get_u16(&value, &out->max_packet_size.value) ||
CBS_len(&value) != 0) {
return false;
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 6935dee..753b951 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -918,7 +918,7 @@
TEST_P(EndToEndTestWithTls, RequestOverMultiplePackets) {
// Send a large enough request to guarantee fragmentation.
std::string huge_request =
- "/some/path?query=" + std::string(kMaxPacketSize, '.');
+ "/some/path?query=" + std::string(kMaxOutgoingPacketSize, '.');
AddToCache(huge_request, 200, kBarResponseBody);
ASSERT_TRUE(Initialize());
@@ -930,7 +930,7 @@
TEST_P(EndToEndTestWithTls, MultiplePacketsRandomOrder) {
// Send a large enough request to guarantee fragmentation.
std::string huge_request =
- "/some/path?query=" + std::string(kMaxPacketSize, '.');
+ "/some/path?query=" + std::string(kMaxOutgoingPacketSize, '.');
AddToCache(huge_request, 200, kBarResponseBody);
ASSERT_TRUE(Initialize());
@@ -1426,7 +1426,7 @@
ASSERT_TRUE(Initialize());
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
- std::string body(kMaxPacketSize, 'a');
+ std::string body(kMaxOutgoingPacketSize, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1450,7 +1450,7 @@
ASSERT_TRUE(Initialize());
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
- std::string body(kMaxPacketSize, 'a');
+ std::string body(kMaxOutgoingPacketSize, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -2267,7 +2267,7 @@
// Test the AckNotifier's ability to track multiple packets by making the
// request body exceed the size of a single packet.
std::string request_string = "a request body bigger than one packet" +
- std::string(kMaxPacketSize, '.');
+ std::string(kMaxOutgoingPacketSize, '.');
// The TestAckListener will cause a failure if not notified.
QuicReferenceCountedPointer<TestAckListener> ack_listener(
@@ -2802,7 +2802,7 @@
// update. This allows headers processing to trigger the error response
// before the request FIN is processed but receive the request FIN before the
// response is sent completely.
- const uint32_t kRequestBodySize = kMaxPacketSize + 10;
+ const uint32_t kRequestBodySize = kMaxOutgoingPacketSize + 10;
std::string request_body(kRequestBodySize, 'a');
// Send the request.
@@ -3552,10 +3552,11 @@
}
SetPacketLossPercentage(30);
- ASSERT_GT(kMaxPacketSize, client_session->GetCurrentLargestMessagePayload());
+ ASSERT_GT(kMaxOutgoingPacketSize,
+ client_session->GetCurrentLargestMessagePayload());
ASSERT_LT(0, client_session->GetCurrentLargestMessagePayload());
- std::string message_string(kMaxPacketSize, 'a');
+ std::string message_string(kMaxOutgoingPacketSize, 'a');
QuicStringPiece message_buffer(message_string);
QuicRandom* random =
QuicConnectionPeer::GetHelper(client_connection)->GetRandomGenerator();
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 190c0ed..e6e7f57 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -703,7 +703,7 @@
EXPECT_CALL(*send_algorithm, CanSend(_)).WillRepeatedly(Return(true));
EXPECT_CALL(*send_algorithm, GetCongestionWindow())
- .WillRepeatedly(Return(kMaxPacketSize * 10));
+ .WillRepeatedly(Return(kMaxOutgoingPacketSize * 10));
EXPECT_CALL(*send_algorithm, InRecovery()).WillRepeatedly(Return(false));
EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
session_.SendStreamData(stream2);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 822b269..d90413a 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -2251,8 +2251,9 @@
packet_generator_.FlushAllQueuedFrames();
}
DCHECK(!packet_generator_.HasQueuedFrames());
- char buffer[kMaxPacketSize];
- packet_generator_.ReserializeAllFrames(pending, buffer, kMaxPacketSize);
+ char buffer[kMaxOutgoingPacketSize];
+ packet_generator_.ReserializeAllFrames(pending, buffer,
+ kMaxOutgoingPacketSize);
}
}
@@ -2420,7 +2421,7 @@
}
}
- DCHECK_LE(encrypted_length, kMaxPacketSize);
+ DCHECK_LE(encrypted_length, kMaxOutgoingPacketSize);
DCHECK_LE(encrypted_length, packet_generator_.GetCurrentMaxPacketLength());
QUIC_DVLOG(1) << ENDPOINT << "Sending packet " << packet_number << " : "
<< (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA
@@ -3427,8 +3428,8 @@
if (max_packet_size > writer_limit) {
max_packet_size = writer_limit;
}
- if (max_packet_size > kMaxPacketSize) {
- max_packet_size = kMaxPacketSize;
+ if (max_packet_size > kMaxOutgoingPacketSize) {
+ max_packet_size = kMaxOutgoingPacketSize;
}
return max_packet_size;
}
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 8176934..7f8b8c8 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -77,9 +77,9 @@
const QuicByteCount kMtuDiscoveryTargetPacketSizeHigh = 1450;
const QuicByteCount kMtuDiscoveryTargetPacketSizeLow = 1430;
-static_assert(kMtuDiscoveryTargetPacketSizeLow <= kMaxPacketSize,
+static_assert(kMtuDiscoveryTargetPacketSizeLow <= kMaxOutgoingPacketSize,
"MTU discovery target is too large");
-static_assert(kMtuDiscoveryTargetPacketSizeHigh <= kMaxPacketSize,
+static_assert(kMtuDiscoveryTargetPacketSizeHigh <= kMaxOutgoingPacketSize,
"MTU discovery target is too large");
static_assert(kMtuDiscoveryTargetPacketSizeLow > kDefaultMaxPacketSize,
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index b36f888..698bf8b 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -337,7 +337,7 @@
packets_write_attempts_(0),
clock_(clock),
write_pause_time_delta_(QuicTime::Delta::Zero()),
- max_packet_size_(kMaxPacketSize),
+ max_packet_size_(kMaxOutgoingPacketSize),
supports_release_time_(false) {}
TestPacketWriter(const TestPacketWriter&) = delete;
TestPacketWriter& operator=(const TestPacketWriter&) = delete;
@@ -612,11 +612,11 @@
HasRetransmittableData retransmittable,
bool has_ack,
bool has_pending_frames) {
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
QuicConnectionPeer::GetFramer(this)->EncryptPayload(
ENCRYPTION_INITIAL, QuicPacketNumber(packet_number), *packet,
- buffer, kMaxPacketSize);
+ buffer, kMaxOutgoingPacketSize);
SerializedPacket serialized_packet(
QuicPacketNumber(packet_number), PACKET_4BYTE_PACKET_NUMBER, buffer,
encrypted_length, has_ack, has_pending_frames);
@@ -1030,10 +1030,10 @@
QuicMakeUnique<NullEncrypter>(peer_framer_.perspective()));
}
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
SerializedPacket serialized_packet =
- QuicPacketCreatorPeer::SerializeAllFrames(&peer_creator_, frames,
- buffer, kMaxPacketSize);
+ QuicPacketCreatorPeer::SerializeAllFrames(
+ &peer_creator_, frames, buffer, kMaxOutgoingPacketSize);
connection_.ProcessUdpPacket(
self_address, peer_address,
QuicReceivedPacket(serialized_packet.encrypted_buffer,
@@ -1052,16 +1052,17 @@
&peer_creator_, connection_.perspective() == Perspective::IS_SERVER);
QuicPacketHeader header;
QuicPacketCreatorPeer::FillPacketHeader(&peer_creator_, &header);
- char encrypted_buffer[kMaxPacketSize];
+ char encrypted_buffer[kMaxOutgoingPacketSize];
size_t length = peer_framer_.BuildDataPacket(
- header, frames, encrypted_buffer, kMaxPacketSize, ENCRYPTION_INITIAL);
+ header, frames, encrypted_buffer, kMaxOutgoingPacketSize,
+ ENCRYPTION_INITIAL);
DCHECK_GT(length, 0u);
const size_t encrypted_length = peer_framer_.EncryptInPlace(
ENCRYPTION_INITIAL, header.packet_number,
GetStartOfEncryptedData(peer_framer_.version().transport_version,
header),
- length, kMaxPacketSize, encrypted_buffer);
+ length, kMaxOutgoingPacketSize, encrypted_buffer);
DCHECK_GT(encrypted_length, 0u);
connection_.ProcessUdpPacket(
@@ -1098,9 +1099,10 @@
QuicMakeUnique<StrictTaggingDecrypter>(0x01));
}
- char buffer[kMaxPacketSize];
- size_t encrypted_length = peer_framer_.EncryptPayload(
- level, QuicPacketNumber(number), *packet, buffer, kMaxPacketSize);
+ char buffer[kMaxOutgoingPacketSize];
+ size_t encrypted_length =
+ peer_framer_.EncryptPayload(level, QuicPacketNumber(number), *packet,
+ buffer, kMaxOutgoingPacketSize);
connection_.ProcessUdpPacket(
kSelfAddress, kPeerAddress,
QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
@@ -1130,10 +1132,11 @@
EncryptionLevel level) {
std::unique_ptr<QuicPacket> packet(
ConstructDataPacket(number, has_stop_waiting, level));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
peer_creator_.set_encryption_level(level);
- size_t encrypted_length = peer_framer_.EncryptPayload(
- level, QuicPacketNumber(number), *packet, buffer, kMaxPacketSize);
+ size_t encrypted_length =
+ peer_framer_.EncryptPayload(level, QuicPacketNumber(number), *packet,
+ buffer, kMaxOutgoingPacketSize);
connection_.ProcessUdpPacket(
kSelfAddress, kPeerAddress,
QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
@@ -1145,10 +1148,10 @@
void ProcessClosePacket(uint64_t number) {
std::unique_ptr<QuicPacket> packet(ConstructClosePacket(number));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length = peer_framer_.EncryptPayload(
ENCRYPTION_INITIAL, QuicPacketNumber(number), *packet, buffer,
- kMaxPacketSize);
+ kMaxOutgoingPacketSize);
connection_.ProcessUdpPacket(
kSelfAddress, kPeerAddress,
QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
@@ -2146,11 +2149,11 @@
frames.push_back(QuicFrame(frame1_));
frames.push_back(QuicFrame(padding));
std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12),
- *packet, buffer, kMaxPacketSize);
- EXPECT_EQ(kMaxPacketSize, encrypted_length);
+ *packet, buffer, kMaxOutgoingPacketSize);
+ EXPECT_EQ(kMaxOutgoingPacketSize, encrypted_length);
framer_.set_version(version());
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
@@ -2158,7 +2161,7 @@
kSelfAddress, kPeerAddress,
QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
- EXPECT_EQ(kMaxPacketSize, connection_.max_packet_length());
+ EXPECT_EQ(kMaxOutgoingPacketSize, connection_.max_packet_length());
}
TEST_P(QuicConnectionTest, IncreaseServerMaxPacketSizeWhileWriterLimited) {
@@ -2190,11 +2193,11 @@
frames.push_back(QuicFrame(frame1_));
frames.push_back(QuicFrame(padding));
std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12),
- *packet, buffer, kMaxPacketSize);
- EXPECT_EQ(kMaxPacketSize, encrypted_length);
+ *packet, buffer, kMaxOutgoingPacketSize);
+ EXPECT_EQ(kMaxOutgoingPacketSize, encrypted_length);
framer_.set_version(version());
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
@@ -2447,7 +2450,7 @@
QuicAckFrame frame = InitAckFrame({{second, second + 1}});
// First nack triggers early retransmit.
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(original, kMaxPacketSize));
+ lost_packets.push_back(LostPacket(original, kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3153,7 +3156,8 @@
// Lose a packet and ensure it triggers retransmission.
QuicAckFrame nack_two = ConstructAckFrame(3, 2);
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(2), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(2), kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3254,7 +3258,7 @@
QuicAckFrame nack_two = ConstructAckFrame(last_packet, last_packet - 1);
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(last_packet - 1, kMaxPacketSize));
+ lost_packets.push_back(LostPacket(last_packet - 1, kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3392,7 +3396,7 @@
QuicAckFrame ack = ConstructAckFrame(last_packet, last_packet - 1);
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(last_packet - 1, kMaxPacketSize));
+ lost_packets.push_back(LostPacket(last_packet - 1, kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3432,7 +3436,8 @@
BlockOnNextWrite();
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(2), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(2), kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3472,7 +3477,7 @@
QuicAckFrame frame = InitAckFrame({{second, second + 1}});
// The first nack should retransmit the largest observed packet.
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(original, kMaxPacketSize));
+ lost_packets.push_back(LostPacket(original, kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3631,10 +3636,10 @@
const EncryptionLevel level = ENCRYPTION_INITIAL;
std::unique_ptr<QuicPacket> packet(ConstructDataPacket(
received_packet_num, has_stop_waiting, ENCRYPTION_INITIAL));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
peer_framer_.EncryptPayload(level, QuicPacketNumber(received_packet_num),
- *packet, buffer, kMaxPacketSize);
+ *packet, buffer, kMaxOutgoingPacketSize);
connection_.ProcessUdpPacket(
kSelfAddress, kPeerAddress,
QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
@@ -3718,7 +3723,8 @@
// 14 packets have been NACK'd and lost.
LostPacketVector lost_packets;
for (int i = 1; i < 15; ++i) {
- lost_packets.push_back(LostPacket(QuicPacketNumber(i), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(i), kMaxOutgoingPacketSize));
}
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
@@ -6412,7 +6418,8 @@
// Ack the second packet, which will retransmit the first packet.
QuicAckFrame ack = ConstructAckFrame(2, 1);
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -6720,10 +6727,10 @@
QuicFrames frames;
frames.push_back(QuicFrame(frame1_));
std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12), *packet,
- buffer, kMaxPacketSize);
+ buffer, kMaxOutgoingPacketSize);
framer_.set_version(version());
// Writer's framer's perspective is client, so that it needs to have the right
@@ -6776,10 +6783,10 @@
QuicFrames frames;
frames.push_back(QuicFrame(frame1_));
std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12), *packet,
- buffer, kMaxPacketSize);
+ buffer, kMaxOutgoingPacketSize);
framer_.set_version(version());
BlockOnNextWrite();
@@ -6839,10 +6846,10 @@
QuicFrames frames;
frames.push_back(QuicFrame(frame1_));
std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encryped_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12), *packet,
- buffer, kMaxPacketSize);
+ buffer, kMaxOutgoingPacketSize);
framer_.set_version(version());
set_perspective(Perspective::IS_SERVER);
@@ -6897,10 +6904,10 @@
QuicFrames frames;
frames.push_back(QuicFrame(frame1_));
std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12),
- *packet, buffer, kMaxPacketSize);
+ *packet, buffer, kMaxOutgoingPacketSize);
ASSERT_NE(0u, encrypted_length);
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ -6962,8 +6969,10 @@
{QuicPacketNumber(4), QuicPacketNumber(5)}});
LostPacketVector lost_packets;
- lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
- lost_packets.push_back(LostPacket(QuicPacketNumber(3), kMaxPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
+ lost_packets.push_back(
+ LostPacket(QuicPacketNumber(3), kMaxOutgoingPacketSize));
EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
.WillOnce(SetArgPointee<5>(lost_packets));
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -7012,9 +7021,10 @@
frames.push_back(QuicFrame(&qccf));
std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
EXPECT_TRUE(nullptr != packet);
- char buffer[kMaxPacketSize];
- size_t encrypted_length = peer_framer_.EncryptPayload(
- ENCRYPTION_INITIAL, QuicPacketNumber(1), *packet, buffer, kMaxPacketSize);
+ char buffer[kMaxOutgoingPacketSize];
+ size_t encrypted_length =
+ peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(1),
+ *packet, buffer, kMaxOutgoingPacketSize);
EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PEER_GOING_AWAY, _,
ConnectionCloseSource::FROM_PEER));
@@ -8431,9 +8441,10 @@
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43));
std::unique_ptr<QuicPacket> packet(
ConstructDataPacket(2, !kHasStopWaiting, ENCRYPTION_INITIAL));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = peer_framer_.EncryptPayload(
- ENCRYPTION_INITIAL, QuicPacketNumber(2), *packet, buffer, kMaxPacketSize);
+ char buffer[kMaxOutgoingPacketSize];
+ size_t encrypted_length =
+ peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(2),
+ *packet, buffer, kMaxOutgoingPacketSize);
// Make sure no stream frame is processed.
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(0);
connection_.ProcessUdpPacket(
diff --git a/quic/core/quic_constants.h b/quic/core/quic_constants.h
index e0bf4ce..4181cb7 100644
--- a/quic/core/quic_constants.h
+++ b/quic/core/quic_constants.h
@@ -32,16 +32,18 @@
const QuicByteCount kDefaultServerMaxPacketSize = 1000;
// Maximum transmission unit on Ethernet.
const QuicByteCount kEthernetMTU = 1500;
-// The maximum packet size of any QUIC packet, based on ethernet's max size,
-// minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
+// The maximum packet size of any QUIC packet over IPv6, based on ethernet's max
+// size, minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
// additional 8 bytes. This is a total overhead of 48 bytes. Ethernet's
// max packet size is 1500 bytes, 1500 - 48 = 1452.
-const QuicByteCount kMaxPacketSize = 1452;
+const QuicByteCount kMaxV6PacketSize = 1452;
// The maximum packet size of any QUIC packet over IPv4.
// 1500(Ethernet) - 20(IPv4 header) - 8(UDP header) = 1472.
const QuicByteCount kMaxV4PacketSize = 1472;
// The maximum incoming packet size allowed.
const QuicByteCount kMaxIncomingPacketSize = kMaxV4PacketSize;
+// The maximum outgoing packet size allowed.
+const QuicByteCount kMaxOutgoingPacketSize = kMaxV6PacketSize;
// ETH_MAX_MTU - MAX(sizeof(iphdr), sizeof(ip6_hdr)) - sizeof(udphdr).
const QuicByteCount kMaxGsoPacketSize = 65535 - 40 - 8;
// Default maximum packet size used in the Linux TCP implementation.
diff --git a/quic/core/quic_default_packet_writer.cc b/quic/core/quic_default_packet_writer.cc
index 3b16a74..a9147c0 100644
--- a/quic/core/quic_default_packet_writer.cc
+++ b/quic/core/quic_default_packet_writer.cc
@@ -40,7 +40,7 @@
QuicByteCount QuicDefaultPacketWriter::GetMaxPacketSize(
const QuicSocketAddress& peer_address) const {
- return kMaxPacketSize;
+ return kMaxOutgoingPacketSize;
}
bool QuicDefaultPacketWriter::SupportsReleaseTime() const {
diff --git a/quic/core/quic_error_codes.h b/quic/core/quic_error_codes.h
index bbdb13f..9954134 100644
--- a/quic/core/quic_error_codes.h
+++ b/quic/core/quic_error_codes.h
@@ -118,7 +118,7 @@
QUIC_DECRYPTION_FAILURE = 12,
// There was an error encrypting.
QUIC_ENCRYPTION_FAILURE = 13,
- // The packet exceeded kMaxPacketSize.
+ // The packet exceeded kMaxOutgoingPacketSize.
QUIC_PACKET_TOO_LARGE = 14,
// The peer is going away. May be a client or server.
QUIC_PEER_GOING_AWAY = 16,
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 4fd6936..c24a23c 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -880,7 +880,7 @@
free_bytes >= GetMinAckFrameSize(version_.transport_version,
PACKET_6BYTE_PACKET_NUMBER);
if (can_truncate) {
- // Truncate the frame so the packet will not exceed kMaxPacketSize.
+ // Truncate the frame so the packet will not exceed kMaxOutgoingPacketSize.
// Note that we may not use every byte of the writer in this case.
QUIC_DLOG(INFO) << ENDPOINT
<< "Truncating large frame, free bytes: " << free_bytes;
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index dc6e231..927b100 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -568,7 +568,7 @@
// packet fragments in |fragments|.
std::unique_ptr<QuicEncryptedPacket> AssemblePacketFromFragments(
const PacketFragments& fragments) {
- char* buffer = new char[kMaxPacketSize + 1];
+ char* buffer = new char[kMaxOutgoingPacketSize + 1];
size_t len = 0;
for (const auto& fragment : fragments) {
memcpy(buffer + len, fragment.fragment.data(), fragment.fragment.size());
@@ -5408,7 +5408,7 @@
QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
// clang-format off
- unsigned char packet[kMaxPacketSize] = {
+ unsigned char packet[kMaxOutgoingPacketSize] = {
// public flags (8 byte connection_id)
0x28,
// connection_id
@@ -5421,7 +5421,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet44[kMaxPacketSize] = {
+ unsigned char packet44[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x32,
// connection_id
@@ -5434,7 +5434,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet46[kMaxPacketSize] = {
+ unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -5447,7 +5447,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet99[kMaxPacketSize] = {
+ unsigned char packet99[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -5475,7 +5475,7 @@
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
- memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+ memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
@@ -5640,7 +5640,7 @@
QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
// clang-format off
- unsigned char packet[kMaxPacketSize] = {
+ unsigned char packet[kMaxOutgoingPacketSize] = {
// public flags (8 byte connection_id and 4 byte packet number)
0x28,
// connection_id
@@ -5653,7 +5653,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet44[kMaxPacketSize] = {
+ unsigned char packet44[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x32,
// connection_id
@@ -5666,7 +5666,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet46[kMaxPacketSize] = {
+ unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -5679,7 +5679,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet99[kMaxPacketSize] = {
+ unsigned char packet99[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -5707,7 +5707,7 @@
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
- memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+ memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
@@ -5729,7 +5729,7 @@
QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
// clang-format off
- unsigned char packet[kMaxPacketSize] = {
+ unsigned char packet[kMaxOutgoingPacketSize] = {
// public flags (8 byte connection_id and 2 byte packet number)
0x18,
// connection_id
@@ -5742,7 +5742,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet44[kMaxPacketSize] = {
+ unsigned char packet44[kMaxOutgoingPacketSize] = {
// type (short header, 2 byte packet number)
0x31,
// connection_id
@@ -5755,7 +5755,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet46[kMaxPacketSize] = {
+ unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 2 byte packet number)
0x41,
// connection_id
@@ -5768,7 +5768,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet99[kMaxPacketSize] = {
+ unsigned char packet99[kMaxOutgoingPacketSize] = {
// type (short header, 2 byte packet number)
0x41,
// connection_id
@@ -5796,7 +5796,7 @@
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_2BYTE_PACKET_NUMBER,
VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
- memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+ memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
@@ -5818,7 +5818,7 @@
QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
// clang-format off
- unsigned char packet[kMaxPacketSize] = {
+ unsigned char packet[kMaxOutgoingPacketSize] = {
// public flags (8 byte connection_id and 1 byte packet number)
0x08,
// connection_id
@@ -5831,7 +5831,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet44[kMaxPacketSize] = {
+ unsigned char packet44[kMaxOutgoingPacketSize] = {
// type (short header, 1 byte packet number)
0x30,
// connection_id
@@ -5844,7 +5844,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet46[kMaxPacketSize] = {
+ unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 1 byte packet number)
0x40,
// connection_id
@@ -5857,7 +5857,7 @@
0x00, 0x00, 0x00, 0x00
};
- unsigned char packet99[kMaxPacketSize] = {
+ unsigned char packet99[kMaxOutgoingPacketSize] = {
// type (short header, 1 byte packet number)
0x40,
// connection_id
@@ -5885,7 +5885,7 @@
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_1BYTE_PACKET_NUMBER,
VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
- memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+ memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
@@ -8599,7 +8599,7 @@
packet_size = QUIC_ARRAYSIZE(packet44);
}
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
size_t length = framer_.BuildConnectivityProbingPacket(
header, buffer.get(), packet_size, ENCRYPTION_INITIAL);
@@ -8645,7 +8645,7 @@
};
// clang-format on
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
MockRandom randomizer;
size_t length = framer_.BuildPaddedPathChallengePacket(
@@ -8698,7 +8698,7 @@
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
};
// clang-format on
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
QuicDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
size_t length = framer_.BuildPathResponsePacket(
@@ -8744,7 +8744,7 @@
0x00, 0x00, 0x00, 0x00, 0x00
};
// clang-format on
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
QuicDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
size_t length = framer_.BuildPathResponsePacket(
@@ -8793,7 +8793,7 @@
};
// clang-format on
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
QuicDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
payloads.push_back(payload1);
@@ -8846,7 +8846,7 @@
};
// clang-format on
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
QuicDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
payloads.push_back(payload1);
@@ -9217,9 +9217,9 @@
PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
!kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxPacketSize);
+ ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
ASSERT_NE(0u, encrypted_length);
EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
@@ -9320,9 +9320,9 @@
kIncludeVersion, !kIncludeDiversificationNonce,
PACKET_4BYTE_PACKET_NUMBER, VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
VARIABLE_LENGTH_INTEGER_LENGTH_0));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxPacketSize);
+ ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
ASSERT_NE(0u, encrypted_length);
EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
@@ -9350,10 +9350,10 @@
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
ASSERT_TRUE(raw_ack_packet != nullptr);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number,
- *raw_ack_packet, buffer, kMaxPacketSize);
+ *raw_ack_packet, buffer, kMaxOutgoingPacketSize);
ASSERT_NE(0u, encrypted_length);
// Now make sure we can turn our ack packet back into an ack frame.
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
@@ -9390,10 +9390,10 @@
std::unique_ptr<QuicPacket> raw_ack_packet(
BuildDataPacket(header, frames, 500));
ASSERT_TRUE(raw_ack_packet != nullptr);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number,
- *raw_ack_packet, buffer, kMaxPacketSize);
+ *raw_ack_packet, buffer, kMaxOutgoingPacketSize);
ASSERT_NE(0u, encrypted_length);
// Now make sure we can turn our ack packet back into an ack frame.
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
@@ -9428,10 +9428,10 @@
std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
ASSERT_TRUE(raw_ack_packet != nullptr);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
size_t encrypted_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number,
- *raw_ack_packet, buffer, kMaxPacketSize);
+ *raw_ack_packet, buffer, kMaxOutgoingPacketSize);
ASSERT_NE(0u, encrypted_length);
// Now make sure we can turn our ack packet back into an ack frame.
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 4d5bd14..96b5bc6 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -266,7 +266,7 @@
// would calculate the correct lengths at the correct time, based on
// the state at that time/place.
QuicFramer::GetMinStreamFrameSize(version, 1u, offset, true,
- kMaxPacketSize);
+ kMaxOutgoingPacketSize);
}
void QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
@@ -364,13 +364,13 @@
return;
}
- QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxPacketSize];
+ QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
char* serialized_packet_buffer = delegate_->GetPacketBuffer();
if (serialized_packet_buffer == nullptr) {
serialized_packet_buffer = stack_buffer;
}
- SerializePacket(serialized_packet_buffer, kMaxPacketSize);
+ SerializePacket(serialized_packet_buffer, kMaxOutgoingPacketSize);
OnSerializedPacket();
}
@@ -418,13 +418,13 @@
QuicPacketHeader header;
FillPacketHeader(&header);
- QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxPacketSize];
+ QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
char* encrypted_buffer = delegate_->GetPacketBuffer();
if (encrypted_buffer == nullptr) {
encrypted_buffer = stack_buffer;
}
- QuicDataWriter writer(kMaxPacketSize, encrypted_buffer);
+ QuicDataWriter writer(kMaxOutgoingPacketSize, encrypted_buffer);
size_t length_field_offset = 0;
if (!framer_->AppendPacketHeader(header, &writer, &length_field_offset)) {
QUIC_BUG << "AppendPacketHeader failed";
@@ -477,7 +477,7 @@
size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header),
- writer.length(), kMaxPacketSize, encrypted_buffer);
+ writer.length(), kMaxOutgoingPacketSize, encrypted_buffer);
if (encrypted_length == 0) {
QUIC_BUG << "Failed to encrypt packet number " << header.packet_number;
return;
@@ -637,7 +637,7 @@
// FillPacketHeader increments packet_number_.
FillPacketHeader(&header);
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
size_t length = framer_->BuildConnectivityProbingPacket(
header, buffer.get(), max_plaintext_size_, packet_.encryption_level);
DCHECK(length);
@@ -645,7 +645,7 @@
const size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header), length,
- kMaxPacketSize, buffer.get());
+ kMaxOutgoingPacketSize, buffer.get());
DCHECK(encrypted_length);
OwningSerializedPacketPointer serialize_packet(new SerializedPacket(
@@ -669,7 +669,7 @@
// FillPacketHeader increments packet_number_.
FillPacketHeader(&header);
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
size_t length = framer_->BuildPaddedPathChallengePacket(
header, buffer.get(), max_plaintext_size_, payload, random_,
packet_.encryption_level);
@@ -678,7 +678,7 @@
const size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header), length,
- kMaxPacketSize, buffer.get());
+ kMaxOutgoingPacketSize, buffer.get());
DCHECK(encrypted_length);
OwningSerializedPacketPointer serialize_packet(new SerializedPacket(
@@ -703,7 +703,7 @@
// FillPacketHeader increments packet_number_.
FillPacketHeader(&header);
- std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+ std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
size_t length = framer_->BuildPathResponsePacket(
header, buffer.get(), max_plaintext_size_, payloads, is_padded,
packet_.encryption_level);
@@ -712,7 +712,7 @@
const size_t encrypted_length = framer_->EncryptInPlace(
packet_.encryption_level, packet_.packet_number,
GetStartOfEncryptedData(framer_->transport_version(), header), length,
- kMaxPacketSize, buffer.get());
+ kMaxOutgoingPacketSize, buffer.get());
DCHECK(encrypted_length);
OwningSerializedPacketPointer serialize_packet(new SerializedPacket(
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index ea93552..85e0091 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -32,8 +32,9 @@
: public QuicConnectionCloseDelegateInterface {
public:
~DelegateInterface() override {}
- // Get a buffer of kMaxPacketSize bytes to serialize the next packet.
- // If return nullptr, QuicPacketCreator will serialize on a stack buffer.
+ // Get a buffer of kMaxOutgoingPacketSize bytes to serialize the next
+ // packet. If return nullptr, QuicPacketCreator will serialize on a stack
+ // buffer.
virtual char* GetPacketBuffer() = 0;
// Called when a packet is serialized. Delegate does not take the ownership
// of |serialized_packet|, but takes ownership of any frames it removes
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index f6d4f5f..d463846 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -173,7 +173,7 @@
SerializedPacket SerializeAllFrames(const QuicFrames& frames) {
SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
- &creator_, frames, buffer_, kMaxPacketSize);
+ &creator_, frames, buffer_, kMaxOutgoingPacketSize);
EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_),
packet.encryption_level);
return packet;
@@ -192,8 +192,8 @@
bool fin) {
EXPECT_EQ(STREAM_FRAME, frame.type);
EXPECT_EQ(stream_id, frame.stream_frame.stream_id);
- char buf[kMaxPacketSize];
- QuicDataWriter writer(kMaxPacketSize, buf, HOST_BYTE_ORDER);
+ char buf[kMaxOutgoingPacketSize];
+ QuicDataWriter writer(kMaxOutgoingPacketSize, buf, HOST_BYTE_ORDER);
if (frame.stream_frame.data_length > 0) {
producer_.WriteStreamData(stream_id, frame.stream_frame.offset,
frame.stream_frame.data_length, &writer);
@@ -254,7 +254,7 @@
static const QuicStreamOffset kOffset = 0u;
- char buffer_[kMaxPacketSize];
+ char buffer_[kMaxOutgoingPacketSize];
QuicConnectionId connection_id_;
QuicFrames frames_;
QuicFramer server_framer_;
@@ -339,13 +339,13 @@
frames.push_back(
QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
}
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
ENCRYPTION_INITIAL, PACKET_4BYTE_PACKET_NUMBER));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
// The packet number length is updated after every packet is sent,
// so there is no need to restore the old length after sending.
EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
@@ -386,14 +386,14 @@
QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
}
creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
ENCRYPTION_INITIAL,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
EXPECT_EQ(ENCRYPTION_INITIAL, serialized_packet_.encryption_level);
DeleteFrames(&frames);
}
@@ -403,14 +403,14 @@
QuicFrames frames;
frames.push_back(QuicFrame(stream_frame));
creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, false /* has_crypto_handshake */, 0 /* no padding */,
ENCRYPTION_INITIAL,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, serialized_packet_.encryption_level);
}
@@ -433,14 +433,14 @@
}
QuicFrames frames;
frames.push_back(frame);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
ENCRYPTION_INITIAL,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
DeleteFrames(&frames);
}
@@ -468,14 +468,15 @@
{
QuicFrames frames;
frames.push_back(frame);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, false /* has_crypto_handshake */,
kNumPaddingBytes1 /* padding bytes */, ENCRYPTION_INITIAL,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer,
+ kMaxOutgoingPacketSize);
packet_size = serialized_packet_.encrypted_length;
}
@@ -500,14 +501,14 @@
const int kNumPaddingBytes2 = 44;
QuicFrames frames;
frames.push_back(frame);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, false /* has_crypto_handshake */,
kNumPaddingBytes2 /* padding bytes */, ENCRYPTION_INITIAL,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
EXPECT_EQ(packet_size, serialized_packet_.encrypted_length);
DeleteFrames(&frames);
@@ -535,14 +536,15 @@
kOffset, false, &frame);
QuicFrames frames;
frames.push_back(frame);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, false /* has_crypto_handshake */, -1 /* needs full padding */,
ENCRYPTION_FORWARD_SECURE,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer,
+ kMaxOutgoingPacketSize);
// If there is not enough space in the packet to fit a padding frame
// (1 byte) and to expand the stream frame (another 2 bytes) the packet
@@ -699,11 +701,12 @@
GetPacketHeaderOverhead(client_framer_.transport_version()) +
GetEncryptionOverhead();
if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
- overhead += QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxPacketSize);
+ overhead +=
+ QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxOutgoingPacketSize);
} else {
overhead += GetStreamFrameOverhead(client_framer_.transport_version());
}
- ASSERT_GT(kMaxPacketSize, overhead);
+ ASSERT_GT(kMaxOutgoingPacketSize, overhead);
size_t capacity = kDefaultMaxPacketSize - overhead;
// Now, test various sizes around this size.
for (int delta = -5; delta <= 5; ++delta) {
@@ -1361,7 +1364,7 @@
CryptoHandshakeMessage message;
message.set_tag(kCHLO);
- message.set_minimum_size(kMaxPacketSize);
+ message.set_minimum_size(kMaxOutgoingPacketSize);
CryptoFramer framer;
std::unique_ptr<QuicData> message_data;
message_data = framer.ConstructHandshakeMessage(message);
@@ -1430,14 +1433,14 @@
/*fin=*/false, 0u, QuicStringPiece());
QuicFrames frames;
frames.push_back(QuicFrame(stream_frame));
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, true, /*num_padding_bytes=*/0, ENCRYPTION_FORWARD_SECURE,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
EXPECT_EQ(0u, creator_.pending_padding_bytes());
{
InSequence s;
@@ -1472,14 +1475,14 @@
0u, false, &frame);
QuicFrames frames;
frames.push_back(frame);
- char buffer[kMaxPacketSize];
+ char buffer[kMaxOutgoingPacketSize];
QuicPendingRetransmission retransmission(CreateRetransmission(
frames, true, /*num_padding_bytes=*/-1, ENCRYPTION_FORWARD_SECURE,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillRepeatedly(
Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+ creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
{
InSequence s;
@@ -1560,7 +1563,7 @@
TEST_P(QuicPacketCreatorTest, FlushWithExternalBuffer) {
creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
- char external_buffer[kMaxPacketSize];
+ char external_buffer[kMaxOutgoingPacketSize];
char* expected_buffer = external_buffer;
EXPECT_CALL(delegate_, GetPacketBuffer()).WillOnce(Return(expected_buffer));
diff --git a/quic/core/quic_packet_generator.cc b/quic/core/quic_packet_generator.cc
index 831689b..6efadcf 100644
--- a/quic/core/quic_packet_generator.cc
+++ b/quic/core/quic_packet_generator.cc
@@ -137,9 +137,9 @@
}
// We determine if we can enter the fast path before executing
// the slow path loop.
- bool run_fast_path = !has_handshake && state != FIN_AND_PADDING &&
- !HasQueuedFrames() &&
- write_length - total_bytes_consumed > kMaxPacketSize;
+ bool run_fast_path =
+ !has_handshake && state != FIN_AND_PADDING && !HasQueuedFrames() &&
+ write_length - total_bytes_consumed > kMaxOutgoingPacketSize;
while (!run_fast_path && delegate_->ShouldGeneratePacket(
HAS_RETRANSMITTABLE_DATA,
@@ -177,9 +177,9 @@
// TODO(ianswett): Move to having the creator flush itself when it's full.
packet_creator_.Flush();
- run_fast_path = !has_handshake && state != FIN_AND_PADDING &&
- !HasQueuedFrames() &&
- write_length - total_bytes_consumed > kMaxPacketSize;
+ run_fast_path =
+ !has_handshake && state != FIN_AND_PADDING && !HasQueuedFrames() &&
+ write_length - total_bytes_consumed > kMaxOutgoingPacketSize;
}
if (run_fast_path) {
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index cb22fd5..9edddfc 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -1046,7 +1046,7 @@
// Send enough data for three packets.
size_t data_len = 3 * kDefaultMaxPacketSize + 1;
size_t packet_len = kDefaultMaxPacketSize + 100;
- ASSERT_LE(packet_len, kMaxPacketSize);
+ ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
generator_.SetMaxPacketLength(packet_len);
EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
@@ -1082,7 +1082,7 @@
// one.
size_t data_len = kDefaultMaxPacketSize;
size_t packet_len = kDefaultMaxPacketSize + 100;
- ASSERT_LE(packet_len, kMaxPacketSize);
+ ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
// We expect to see three packets in total.
EXPECT_CALL(delegate_, OnSerializedPacket(_))
@@ -1136,7 +1136,7 @@
size_t first_write_len = kDefaultMaxPacketSize / 2;
size_t packet_len = kDefaultMaxPacketSize + 100;
size_t second_write_len = packet_len + 1;
- ASSERT_LE(packet_len, kMaxPacketSize);
+ ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
// First send half of the packet worth of data. We are in the batch mode, so
// should not cause packet serialization.
@@ -1223,7 +1223,7 @@
delegate_.SetCanWriteAnything();
const size_t target_mtu = kDefaultMaxPacketSize + 100;
- static_assert(target_mtu < kMaxPacketSize,
+ static_assert(target_mtu < kMaxOutgoingPacketSize,
"The MTU probe used by the test exceeds maximum packet size");
EXPECT_CALL(delegate_, OnSerializedPacket(_))
@@ -1248,7 +1248,7 @@
delegate_.SetCanWriteAnything();
const size_t target_mtu = kDefaultMaxPacketSize + 100;
- static_assert(target_mtu < kMaxPacketSize,
+ static_assert(target_mtu < kMaxOutgoingPacketSize,
"The MTU probe used by the test exceeds maximum packet size");
// Send enough data so it would always cause two packets to be sent.
diff --git a/quic/core/quic_packet_reader.cc b/quic/core/quic_packet_reader.cc
index 3216013..f03aa6d 100644
--- a/quic/core/quic_packet_reader.cc
+++ b/quic/core/quic_packet_reader.cc
@@ -83,7 +83,7 @@
#if MMSG_MORE_NO_ANDROID
// Re-set the length fields in case recvmmsg has changed them.
for (int i = 0; i < kNumPacketsPerReadMmsgCall; ++i) {
- DCHECK_LE(kMaxPacketSize, packets_[i].iov.iov_len);
+ DCHECK_LE(kMaxOutgoingPacketSize, packets_[i].iov.iov_len);
msghdr* hdr = &mmsg_hdr_[i].msg_hdr;
hdr->msg_namelen = sizeof(sockaddr_storage);
DCHECK_EQ(1, hdr->msg_iovlen);
diff --git a/quic/core/quic_packet_writer.h b/quic/core/quic_packet_writer.h
index c33e9b7..667254f 100644
--- a/quic/core/quic_packet_writer.h
+++ b/quic/core/quic_packet_writer.h
@@ -107,11 +107,11 @@
//
// Batch mode:
// Return the starting address for the next packet's data. A minimum of
- // kMaxPacketSize is guaranteed to be available from the returned address. If
- // the internal buffer does not have enough space, nullptr is returned.
- // All arguments should be identical to the follow-up call to |WritePacket|,
- // they are here to allow advanced packet memory management in packet writers,
- // e.g. one packet buffer pool per |peer_address|.
+ // kMaxOutgoingPacketSize is guaranteed to be available from the returned
+ // address. If the internal buffer does not have enough space, nullptr is
+ // returned. All arguments should be identical to the follow-up call to
+ // |WritePacket|, they are here to allow advanced packet memory management in
+ // packet writers, e.g. one packet buffer pool per |peer_address|.
virtual char* GetNextWriteLocation(const QuicIpAddress& self_address,
const QuicSocketAddress& peer_address) = 0;
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index f3016f4..eb76c95 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -842,7 +842,7 @@
EXPECT_CALL(*send_algorithm, CanSend(_)).WillRepeatedly(Return(true));
EXPECT_CALL(*send_algorithm, GetCongestionWindow())
- .WillRepeatedly(Return(kMaxPacketSize * 10));
+ .WillRepeatedly(Return(kMaxOutgoingPacketSize * 10));
EXPECT_CALL(*send_algorithm, InRecovery()).WillRepeatedly(Return(false));
EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
session_.SendStreamData(stream2);
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 87f1d6e..e154482 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -72,7 +72,7 @@
class QuicStreamTestBase : public QuicTestWithParam<ParsedQuicVersion> {
public:
QuicStreamTestBase()
- : initial_flow_control_window_bytes_(kMaxPacketSize),
+ : initial_flow_control_window_bytes_(kMaxOutgoingPacketSize),
zero_(QuicTime::Delta::Zero()),
supported_versions_(AllSupportedVersions()) {}
diff --git a/quic/core/quic_trace_visitor_test.cc b/quic/core/quic_trace_visitor_test.cc
index ee179bb..1a58153 100644
--- a/quic/core/quic_trace_visitor_test.cc
+++ b/quic/core/quic_trace_visitor_test.cc
@@ -16,7 +16,7 @@
namespace quic {
namespace {
-const QuicByteCount kTransferSize = 1000 * kMaxPacketSize;
+const QuicByteCount kTransferSize = 1000 * kMaxOutgoingPacketSize;
const QuicByteCount kTestStreamNumber = 3;
const QuicTime::Delta kDelay = QuicTime::Delta::FromMilliseconds(20);
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index db57071..e5988e0 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -109,7 +109,8 @@
QuicFramer* framer,
const QuicPacketHeader& header,
const QuicFrames& frames) {
- const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize);
+ const size_t max_plaintext_size =
+ framer->GetMaxPlaintextSize(kMaxOutgoingPacketSize);
size_t packet_size = GetPacketHeaderSize(framer->transport_version(), header);
for (size_t i = 0; i < frames.size(); ++i) {
DCHECK_LE(packet_size, max_plaintext_size);
@@ -698,7 +699,7 @@
MockPacketWriter::MockPacketWriter() {
ON_CALL(*this, GetMaxPacketSize(_))
- .WillByDefault(testing::Return(kMaxPacketSize));
+ .WillByDefault(testing::Return(kMaxOutgoingPacketSize));
ON_CALL(*this, IsBatchMode()).WillByDefault(testing::Return(false));
ON_CALL(*this, GetNextWriteLocation(_, _))
.WillByDefault(testing::Return(nullptr));
@@ -882,10 +883,10 @@
std::unique_ptr<QuicPacket> packet(
BuildUnsizedDataPacket(&framer, header, frames));
EXPECT_TRUE(packet != nullptr);
- char* buffer = new char[kMaxPacketSize];
+ char* buffer = new char[kMaxOutgoingPacketSize];
size_t encrypted_length =
framer.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(packet_number),
- *packet, buffer, kMaxPacketSize);
+ *packet, buffer, kMaxOutgoingPacketSize);
EXPECT_NE(0u, encrypted_length);
DeleteFrames(&frames);
return new QuicEncryptedPacket(buffer, encrypted_length, true);
@@ -943,10 +944,10 @@
VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0)] =
0x1F;
- char* buffer = new char[kMaxPacketSize];
+ char* buffer = new char[kMaxOutgoingPacketSize];
size_t encrypted_length =
framer.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(packet_number),
- *packet, buffer, kMaxPacketSize);
+ *packet, buffer, kMaxOutgoingPacketSize);
EXPECT_NE(0u, encrypted_length);
return new QuicEncryptedPacket(buffer, encrypted_length, true);
}
@@ -1137,12 +1138,13 @@
QuicStringPiece message_data,
QuicMemSliceStorage* storage) {
if (message_data.length() == 0) {
- *storage = QuicMemSliceStorage(nullptr, 0, allocator, kMaxPacketSize);
+ *storage =
+ QuicMemSliceStorage(nullptr, 0, allocator, kMaxOutgoingPacketSize);
return storage->ToSpan();
}
struct iovec iov = {const_cast<char*>(message_data.data()),
message_data.length()};
- *storage = QuicMemSliceStorage(&iov, 1, allocator, kMaxPacketSize);
+ *storage = QuicMemSliceStorage(&iov, 1, allocator, kMaxOutgoingPacketSize);
return storage->ToSpan();
}
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index b0ce5ca..1072724 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -65,7 +65,7 @@
writer_(this),
nic_tx_queue_(simulator,
QuicStringPrintf("%s (TX Queue)", name.c_str()),
- kMaxPacketSize * kTxQueueSize),
+ kMaxOutgoingPacketSize * kTxQueueSize),
connection_(connection_id,
GetAddressFromName(peer_name),
simulator,
@@ -204,7 +204,7 @@
void QuicEndpoint::OnPacketDequeued() {
if (writer_.IsWriteBlocked() &&
(nic_tx_queue_.capacity() - nic_tx_queue_.bytes_queued()) >=
- kMaxPacketSize) {
+ kMaxOutgoingPacketSize) {
writer_.SetWritable();
connection_.OnCanWrite();
}
@@ -290,7 +290,7 @@
PerPacketOptions* options) {
DCHECK(!IsWriteBlocked());
DCHECK(options == nullptr);
- DCHECK(buf_len <= kMaxPacketSize);
+ DCHECK(buf_len <= kMaxOutgoingPacketSize);
// Instead of losing a packet, become write-blocked when the egress queue is
// full.
@@ -323,7 +323,7 @@
QuicByteCount QuicEndpoint::Writer::GetMaxPacketSize(
const QuicSocketAddress& /*peer_address*/) const {
- return kMaxPacketSize;
+ return kMaxOutgoingPacketSize;
}
bool QuicEndpoint::Writer::SupportsReleaseTime() const {
diff --git a/quic/test_tools/simulator/quic_endpoint_test.cc b/quic/test_tools/simulator/quic_endpoint_test.cc
index 0b25096..5382eb5 100644
--- a/quic/test_tools/simulator/quic_endpoint_test.cc
+++ b/quic/test_tools/simulator/quic_endpoint_test.cc
@@ -104,7 +104,7 @@
.WillRepeatedly(Return(10 * kDefaultBandwidth));
EXPECT_CALL(*sender, GetCongestionWindow())
.WillRepeatedly(
- Return(kMaxPacketSize * kDefaultMaxCongestionWindowPackets));
+ Return(kMaxOutgoingPacketSize * kDefaultMaxCongestionWindowPackets));
test::QuicConnectionPeer::SetSendAlgorithm(endpoint_a.connection(), sender);
// First transmit a small, packet-size chunk of data.
