lib/mvfst
1
0
Fork 0
mirror of https://github.com/facebookincubator/mvfst.git synced 2025-08-06 22:22:38 +03:00
Code Activity

Put outstanding packets, events and associated counters in one class

Browse Source 
Summary: ^

Reviewed By: yangchi

Differential Revision: D21956286

fbshipit-source-id: 305b879ad11df23aae8e0c3aac4645c0136b3012
This commit is contained in:
Xiaoting Tang
2020-06-10 12:43:08 -07:00
committed by Facebook GitHub Bot
parent 621ad3bc0c
commit 2d00d56fbd
31 changed files with 473 additions and 465 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
quic/api/QuicPacketScheduler.cpp
View File

@@ -510,9 +510,9 @@ CloningScheduler::CloningScheduler(
bool CloningScheduler::hasData() const {
return frameScheduler_.hasData() ||
(!conn_.outstandingPackets.empty() &&
conn_.outstandingPackets.size() !=
conn_.outstandingHandshakePacketsCount);
(!conn_.outstandings.packets.empty() &&
conn_.outstandings.packets.size() !=
conn_.outstandings.handshakePacketsCount);
}
SchedulingResult CloningScheduler::scheduleFramesForPacket(
@@ -534,8 +534,8 @@ SchedulingResult CloningScheduler::scheduleFramesForPacket(
std::move(builder).releaseOutputBuffer();
// Look for an outstanding packet that's no larger than the writableBytes
// This is a loop, but it builds at most one packet.
for (auto iter = conn_.outstandingPackets.rbegin();
iter != conn_.outstandingPackets.rend();
for (auto iter = conn_.outstandings.packets.rbegin();
iter != conn_.outstandings.packets.rend();
++iter) {
auto opPnSpace = iter->packet.header.getPacketNumberSpace();
if (opPnSpace != PacketNumberSpace::AppData) {
@@ -573,7 +573,7 @@ SchedulingResult CloningScheduler::scheduleFramesForPacket(
// If the packet is already a clone that has been processed, we don't clone
// it again.
if (iter->associatedEvent &&
conn_.outstandingPacketEvents.count(*iter->associatedEvent) == 0) {
conn_.outstandings.packetEvents.count(*iter->associatedEvent) == 0) {
continue;
}
// I think this only fail if udpSendPacketLen somehow shrinks in the middle

8
quic/api/QuicTransportBase.cpp
View File

@@ -412,8 +412,8 @@ void QuicTransportBase::closeImpl(
connCallback_ = nullptr;
// Don't need outstanding packets.
conn_->outstandingPackets.clear();
conn_->outstandingHandshakePacketsCount = 0;
conn_->outstandings.packets.clear();
conn_->outstandings.handshakePacketsCount = 0;
// We don't need no congestion control.
conn_->congestionController = nullptr;
@@ -2333,7 +2333,7 @@ void QuicTransportBase::cancelAllAppCallbacks(
void QuicTransportBase::writeSocketData() {
if (socket_) {
auto packetsBefore = conn_->outstandingPackets.size();
auto packetsBefore = conn_->outstandings.packets.size();
writeData();
if (closeState_ != CloseState::CLOSED) {
if (conn_->pendingEvents.closeTransport == true) {
@@ -2342,7 +2342,7 @@ void QuicTransportBase::writeSocketData() {
TransportErrorCode::PROTOCOL_VIOLATION);
}
setLossDetectionAlarm(*conn_, *this);
auto packetsAfter = conn_->outstandingPackets.size();
auto packetsAfter = conn_->outstandings.packets.size();
bool packetWritten = (packetsAfter > packetsBefore);
if (conn_->loopDetectorCallback && packetWritten) {
conn_->writeDebugState.currentEmptyLoopCount = 0;

20
quic/api/QuicTransportFunctions.cpp
View File

@@ -621,14 +621,14 @@ void updateConnection(
}
auto packetIt =
std::find_if(
conn.outstandingPackets.rbegin(),
conn.outstandingPackets.rend(),
conn.outstandings.packets.rbegin(),
conn.outstandings.packets.rend(),
[packetNum](const auto& packetWithTime) {
return packetWithTime.packet.header.getPacketSequenceNum() <
packetNum;
})
.base();
auto& pkt = *conn.outstandingPackets.emplace(
auto& pkt = *conn.outstandings.packets.emplace(
packetIt,
std::move(packet),
std::move(sentTime),
@@ -647,7 +647,7 @@ void updateConnection(
conn.lossState.totalBytesAckedAtLastAck);
}
if (packetEvent) {
DCHECK(conn.outstandingPacketEvents.count(*packetEvent));
DCHECK(conn.outstandings.packetEvents.count(*packetEvent));
DCHECK(!isHandshake);
pkt.associatedEvent = std::move(packetEvent);
conn.lossState.totalBytesCloned += encodedSize;
@@ -675,19 +675,19 @@ void updateConnection(
conn.pathValidationLimiter->onPacketSent(pkt.encodedSize);
}
if (pkt.isHandshake) {
++conn.outstandingHandshakePacketsCount;
++conn.outstandings.handshakePacketsCount;
conn.lossState.lastHandshakePacketSentTime = pkt.time;
}
conn.lossState.lastRetransmittablePacketSentTime = pkt.time;
if (pkt.associatedEvent) {
CHECK_EQ(packetNumberSpace, PacketNumberSpace::AppData);
++conn.outstandingClonedPacketsCount;
++conn.outstandings.clonedPacketsCount;
++conn.lossState.timeoutBasedRtxCount;
}
auto opCount = conn.outstandingPackets.size();
DCHECK_GE(opCount, conn.outstandingHandshakePacketsCount);
DCHECK_GE(opCount, conn.outstandingClonedPacketsCount);
auto opCount = conn.outstandings.packets.size();
DCHECK_GE(opCount, conn.outstandings.handshakePacketsCount);
DCHECK_GE(opCount, conn.outstandings.clonedPacketsCount);
}
uint64_t congestionControlWritableBytes(const QuicConnectionStateBase& conn) {
@@ -1353,7 +1353,7 @@ void implicitAckCryptoStream(
AckBlocks ackBlocks;
ReadAckFrame implicitAck;
implicitAck.ackDelay = 0ms;
for (const auto& op : conn.outstandingPackets) {
for (const auto& op : conn.outstandings.packets) {
if (op.packet.header.getPacketNumberSpace() == packetNumSpace) {
ackBlocks.insert(op.packet.header.getPacketSequenceNum());
}

38
quic/api/test/QuicPacketSchedulerTest.cpp
View File

@@ -37,8 +37,8 @@ PacketNum addInitialOutstandingPacket(QuicConnectionStateBase& conn) {
nextPacketNum,
QuicVersion::QUIC_DRAFT);
RegularQuicWritePacket packet(std::move(header));
conn.outstandingPackets.emplace_back(packet, Clock::now(), 0, true, 0);
conn.outstandingHandshakePacketsCount++;
conn.outstandings.packets.emplace_back(packet, Clock::now(), 0, true, 0);
conn.outstandings.handshakePacketsCount++;
increaseNextPacketNum(conn, PacketNumberSpace::Handshake);
return nextPacketNum;
}
@@ -55,8 +55,8 @@ PacketNum addHandshakeOutstandingPacket(QuicConnectionStateBase& conn) {
nextPacketNum,
QuicVersion::QUIC_DRAFT);
RegularQuicWritePacket packet(std::move(header));
conn.outstandingPackets.emplace_back(packet, Clock::now(), 0, true, 0);
conn.outstandingHandshakePacketsCount++;
conn.outstandings.packets.emplace_back(packet, Clock::now(), 0, true, 0);
conn.outstandings.handshakePacketsCount++;
increaseNextPacketNum(conn, PacketNumberSpace::Handshake);
return nextPacketNum;
}
@@ -68,7 +68,7 @@ PacketNum addOutstandingPacket(QuicConnectionStateBase& conn) {
conn.clientConnectionId.value_or(quic::test::getTestConnectionId()),
nextPacketNum);
RegularQuicWritePacket packet(std::move(header));
conn.outstandingPackets.emplace_back(packet, Clock::now(), 0, false, 0);
conn.outstandings.packets.emplace_back(packet, Clock::now(), 0, false, 0);
increaseNextPacketNum(conn, PacketNumberSpace::AppData);
return nextPacketNum;
}
@@ -436,7 +436,7 @@ TEST_F(QuicPacketSchedulerTest, CloningSchedulerTest) {
EXPECT_FALSE(cloningScheduler.hasData());
auto packetNum = addOutstandingPacket(conn);
// There needs to have retransmittable frame for the rebuilder to work
conn.outstandingPackets.back().packet.frames.push_back(
conn.outstandings.packets.back().packet.frames.push_back(
MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
EXPECT_TRUE(cloningScheduler.hasData());
@@ -461,15 +461,15 @@ TEST_F(QuicPacketSchedulerTest, DoNotCloneProcessedClonedPacket) {
FrameScheduler noopScheduler("frame");
CloningScheduler cloningScheduler(noopScheduler, conn, "CopyCat", 0);
// Add two outstanding packets, but then mark the second one processed by
// adding a PacketEvent that's missing from the outstandingPacketEvents set
// adding a PacketEvent that's missing from the outstandings.packetEvents set
PacketNum expected = addOutstandingPacket(conn);
// There needs to have retransmittable frame for the rebuilder to work
conn.outstandingPackets.back().packet.frames.push_back(
conn.outstandings.packets.back().packet.frames.push_back(
MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
addOutstandingPacket(conn);
conn.outstandingPackets.back().associatedEvent = 1;
conn.outstandings.packets.back().associatedEvent = 1;
// There needs to have retransmittable frame for the rebuilder to work
conn.outstandingPackets.back().packet.frames.push_back(
conn.outstandings.packets.back().packet.frames.push_back(
MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
ShortHeader header(
@@ -511,10 +511,10 @@ TEST_F(QuicPacketSchedulerTest, DoNotCloneHandshake) {
// Add two outstanding packets, with second one being handshake
auto expected = addOutstandingPacket(conn);
// There needs to have retransmittable frame for the rebuilder to work
conn.outstandingPackets.back().packet.frames.push_back(
conn.outstandings.packets.back().packet.frames.push_back(
MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
addHandshakeOutstandingPacket(conn);
conn.outstandingPackets.back().packet.frames.push_back(
conn.outstandings.packets.back().packet.frames.push_back(
MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
ShortHeader header(
@@ -587,9 +587,9 @@ TEST_F(QuicPacketSchedulerTest, CloneWillGenerateNewWindowUpdate) {
FrameScheduler noopScheduler("frame");
CloningScheduler cloningScheduler(noopScheduler, conn, "GiantsShoulder", 0);
auto expectedPacketEvent = addOutstandingPacket(conn);
ASSERT_EQ(1, conn.outstandingPackets.size());
conn.outstandingPackets.back().packet.frames.push_back(MaxDataFrame(1000));
conn.outstandingPackets.back().packet.frames.push_back(
ASSERT_EQ(1, conn.outstandings.packets.size());
conn.outstandings.packets.back().packet.frames.push_back(MaxDataFrame(1000));
conn.outstandings.packets.back().packet.frames.push_back(
MaxStreamDataFrame(stream->id, 1000));
conn.flowControlState.advertisedMaxOffset = 1000;
stream->flowControlState.advertisedMaxOffset = 1000;
@@ -674,7 +674,7 @@ TEST_F(QuicPacketSchedulerTest, CloningSchedulerWithInplaceBuilder) {
CloningScheduler cloningScheduler(noopScheduler, conn, "93MillionMiles", 0);
auto packetNum = addOutstandingPacket(conn);
// There needs to have retransmittable frame for the rebuilder to work
conn.outstandingPackets.back().packet.frames.push_back(
conn.outstandings.packets.back().packet.frames.push_back(
MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
EXPECT_TRUE(cloningScheduler.hasData());
@@ -1227,10 +1227,10 @@ TEST_F(
CloningScheduler cloningScheduler(noopScheduler, conn, "Little Hurry", 0);
addOutstandingPacket(conn);
// There needs to have retransmittable frame for the rebuilder to work
conn.outstandingPackets.back().packet.frames.push_back(
conn.outstandings.packets.back().packet.frames.push_back(
MaxDataFrame(conn.flowControlState.advertisedMaxOffset));
// Lie about the encodedSize to let the Cloner skip it:
conn.outstandingPackets.back().encodedSize = kDefaultUDPSendPacketLen * 2;
conn.outstandings.packets.back().encodedSize = kDefaultUDPSendPacketLen * 2;
EXPECT_TRUE(cloningScheduler.hasData());
ASSERT_FALSE(noopScheduler.hasData());
@@ -1270,7 +1270,7 @@ TEST_F(
CloningScheduler cloningScheduler(noopScheduler, conn, "HotPot", 0);
addOutstandingPacket(conn);
// Not adding frame to this outstanding packet so that rebuild will fail:
ASSERT_TRUE(conn.outstandingPackets.back().packet.frames.empty());
ASSERT_TRUE(conn.outstandings.packets.back().packet.frames.empty());
EXPECT_TRUE(cloningScheduler.hasData());
ASSERT_FALSE(noopScheduler.hasData());

4
quic/api/test/QuicTransportBaseTest.cpp
View File

@@ -1189,9 +1189,9 @@ TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksMap) {
}
TEST_F(QuicTransportImplTest, CloseTransportCleansupOutstandingCounters) {
transport->transportConn->outstandingHandshakePacketsCount = 200;
transport->transportConn->outstandings.handshakePacketsCount = 200;
transport->closeNow(folly::none);
EXPECT_EQ(0, transport->transportConn->outstandingHandshakePacketsCount);
EXPECT_EQ(0, transport->transportConn->outstandings.handshakePacketsCount);
}
TEST_F(QuicTransportImplTest, DeliveryCallbackUnsetAll) {

150
quic/api/test/QuicTransportFunctionsTest.cpp
View File

@@ -227,7 +227,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
EXPECT_EQ(
conn->ackStates.appDataAckState.nextPacketNum,
currentNextAppDataPacketNum);
EXPECT_TRUE(conn->outstandingPackets.back().isAppLimited);
EXPECT_TRUE(conn->outstandings.packets.back().isAppLimited);
EXPECT_EQ(stream1->retransmissionBuffer.size(), 1);
auto& rt1 = *stream1->retransmissionBuffer.at(0);
@@ -284,7 +284,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
EXPECT_EQ(
conn->ackStates.appDataAckState.nextPacketNum,
currentNextAppDataPacketNum);
EXPECT_FALSE(conn->outstandingPackets.back().isAppLimited);
EXPECT_FALSE(conn->outstandings.packets.back().isAppLimited);
EXPECT_EQ(stream1->currentWriteOffset, 13);
EXPECT_EQ(stream1->currentWriteOffset, 13);
@@ -399,15 +399,15 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPacketSorting) {
EXPECT_EQ(event2->packetType, toString(LongHeader::Types::Initial));
EXPECT_EQ(event3->packetType, toString(LongHeader::Types::ZeroRtt));
EXPECT_EQ(3, conn->outstandingPackets.size());
auto& firstHeader = conn->outstandingPackets.front().packet.header;
EXPECT_EQ(3, conn->outstandings.packets.size());
auto& firstHeader = conn->outstandings.packets.front().packet.header;
auto firstPacketNum = firstHeader.getPacketSequenceNum();
EXPECT_EQ(0, firstPacketNum);
EXPECT_EQ(1, event1->packetNum);
EXPECT_EQ(PacketNumberSpace::Initial, firstHeader.getPacketNumberSpace());
auto& lastHeader = conn->outstandingPackets.back().packet.header;
auto& lastHeader = conn->outstandings.packets.back().packet.header;
auto lastPacketNum = lastHeader.getPacketSequenceNum();
@@ -539,7 +539,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPureAckCounter) {
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto stream = conn->streamManager->createNextBidirectionalStream().value();
writeDataToQuicStream(*stream, nullptr, true);
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto packetEncodedSize =
@@ -629,8 +629,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
initialStream->writeBuffer.append(data->clone());
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
EXPECT_EQ(1, conn->outstandings.packets.size());
EXPECT_EQ(1, initialStream->retransmissionBuffer.size());
packet = buildEmptyPacket(*conn, PacketNumberSpace::Initial);
@@ -642,8 +642,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
initialStream->writeBuffer.append(data->clone());
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_EQ(2, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(2, conn->outstandings.handshakePacketsCount);
EXPECT_EQ(2, conn->outstandings.packets.size());
EXPECT_EQ(3, initialStream->retransmissionBuffer.size());
EXPECT_TRUE(initialStream->writeBuffer.empty());
EXPECT_TRUE(initialStream->lossBuffer.empty());
@@ -653,8 +653,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
initialStream->retransmissionBuffer.find(0)->second->data.move();
initialStream->retransmissionBuffer.erase(0);
initialStream->lossBuffer.emplace_back(std::move(firstBuf), 0, false);
conn->outstandingPackets.pop_front();
conn->outstandingHandshakePacketsCount--;
conn->outstandings.packets.pop_front();
conn->outstandings.handshakePacketsCount--;
auto handshakeStream =
getCryptoStream(*conn->cryptoState, EncryptionLevel::Handshake);
@@ -666,8 +666,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
handshakeStream->writeBuffer.append(data->clone());
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_EQ(2, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(2, conn->outstandings.handshakePacketsCount);
EXPECT_EQ(2, conn->outstandings.packets.size());
EXPECT_EQ(1, handshakeStream->retransmissionBuffer.size());
packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
@@ -676,8 +676,8 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
handshakeStream->writeBuffer.append(data->clone());
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_EQ(3, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(3, conn->outstandingPackets.size());
EXPECT_EQ(3, conn->outstandings.handshakePacketsCount);
EXPECT_EQ(3, conn->outstandings.packets.size());
EXPECT_EQ(2, handshakeStream->retransmissionBuffer.size());
EXPECT_TRUE(handshakeStream->writeBuffer.empty());
EXPECT_TRUE(handshakeStream->lossBuffer.empty());
@@ -686,24 +686,24 @@ TEST_F(QuicTransportFunctionsTest, TestImplicitAck) {
firstBuf = handshakeStream->retransmissionBuffer.find(0)->second->data.move();
handshakeStream->retransmissionBuffer.erase(0);
handshakeStream->lossBuffer.emplace_back(std::move(firstBuf), 0, false);
auto& op = conn->outstandingPackets.front();
auto& op = conn->outstandings.packets.front();
ASSERT_EQ(
op.packet.header.getPacketNumberSpace(), PacketNumberSpace::Handshake);
auto frame = op.packet.frames[0].asWriteCryptoFrame();
EXPECT_EQ(frame->offset, 0);
conn->outstandingPackets.pop_front();
conn->outstandingHandshakePacketsCount--;
conn->outstandings.packets.pop_front();
conn->outstandings.handshakePacketsCount--;
implicitAckCryptoStream(*conn, EncryptionLevel::Initial);
EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
EXPECT_EQ(1, conn->outstandings.packets.size());
EXPECT_TRUE(initialStream->retransmissionBuffer.empty());
EXPECT_TRUE(initialStream->writeBuffer.empty());
EXPECT_TRUE(initialStream->lossBuffer.empty());
implicitAckCryptoStream(*conn, EncryptionLevel::Handshake);
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
EXPECT_TRUE(conn->outstandingPackets.empty());
EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
EXPECT_TRUE(conn->outstandings.packets.empty());
EXPECT_TRUE(handshakeStream->retransmissionBuffer.empty());
EXPECT_TRUE(handshakeStream->writeBuffer.empty());
EXPECT_TRUE(handshakeStream->lossBuffer.empty());
@@ -714,7 +714,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto stream = conn->streamManager->createNextBidirectionalStream().value();
writeDataToQuicStream(*stream, nullptr, true);
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
auto packetEncodedSize =
@@ -724,7 +724,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
packet.packet.frames.push_back(WriteCryptoFrame(0, 0));
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
auto nonHandshake = buildEmptyPacket(*conn, PacketNumberSpace::AppData);
packetEncodedSize =
@@ -771,7 +771,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
EXPECT_EQ(gotFrame->offset, 0);
EXPECT_EQ(gotFrame->len, 0);
EXPECT_TRUE(gotFrame->fin);
EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
}
}
}
@@ -781,7 +781,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
auto stream = conn->streamManager->createNextBidirectionalStream().value();
writeDataToQuicStream(*stream, nullptr, true);
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
// Packet with CryptoFrame in AppData pn space
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::AppData, true);
@@ -793,8 +793,8 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
EXPECT_EQ(1, conn->outstandings.packets.size());
auto nonHandshake = buildEmptyPacket(*conn, PacketNumberSpace::AppData);
packetEncodedSize =
@@ -843,8 +843,8 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
}
}
EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(0, conn->outstandings.handshakePacketsCount);
EXPECT_EQ(2, conn->outstandings.packets.size());
}
TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
@@ -866,7 +866,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
EXPECT_CALL(*rawPacer, onPacketSent()).Times(0);
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_EQ(0, conn->outstandingPackets.size());
EXPECT_EQ(0, conn->outstandings.packets.size());
EXPECT_EQ(0, conn->lossState.totalBytesAcked);
std::shared_ptr<quic::FileQLogger> qLogger =
std::dynamic_pointer_cast<quic::FileQLogger>(conn->qLogger);
@@ -961,7 +961,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) {
conn->pendingEvents.connWindowUpdate = true;
writePacket.frames.push_back(std::move(maxDataFrame));
PacketEvent event = 1;
conn->outstandingPacketEvents.insert(event);
conn->outstandings.packetEvents.insert(event);
auto futureMoment = thisMoment + 50ms;
MockClock::mockNow = [=]() { return futureMoment; };
EXPECT_CALL(*rawCongestionController, onPacketSent(_)).Times(1);
@@ -1308,7 +1308,7 @@ TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketWithNoBytesForHeader) {
getVersion(*conn),
conn->transportSettings.writeConnectionDataPacketsLimit);
// No header space left. Should send nothing.
EXPECT_TRUE(conn->outstandingPackets.empty());
EXPECT_TRUE(conn->outstandings.packets.empty());
}
TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketRetxBufferSorted) {
@@ -1428,14 +1428,14 @@ TEST_F(QuicTransportFunctionsTest, WriteBlockedFrameWhenBlocked) {
EXPECT_GT(conn->ackStates.appDataAckState.nextPacketNum, originalNextSeq);
auto blocked = *getFirstFrameInOutstandingPackets(
conn->outstandingPackets,
conn->outstandings.packets,
QuicWriteFrame::Type::StreamDataBlockedFrame_E)
.asStreamDataBlockedFrame();
EXPECT_EQ(blocked.streamId, stream1->id);
// Since everything is blocked, we shouldn't write a blocked again, so we
// won't have any new packets to write if we trigger a write.
auto previousPackets = conn->outstandingPackets.size();
auto previousPackets = conn->outstandings.packets.size();
EXPECT_CALL(*transportInfoCb_, onWrite(_)).Times(0);
writeQuicDataToSocket(
*rawSocket,
@@ -1446,7 +1446,7 @@ TEST_F(QuicTransportFunctionsTest, WriteBlockedFrameWhenBlocked) {
*headerCipher,
getVersion(*conn),
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(previousPackets, conn->outstandingPackets.size());
EXPECT_EQ(previousPackets, conn->outstandings.packets.size());
}
TEST_F(QuicTransportFunctionsTest, WriteProbingNewData) {
@@ -1478,9 +1478,9 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingNewData) {
writeProbingDataToSocketForTest(
*rawSocket, *conn, 1, *aead, *headerCipher, getVersion(*conn));
EXPECT_LT(currentPacketSeqNum, conn->ackStates.appDataAckState.nextPacketNum);
EXPECT_FALSE(conn->outstandingPackets.empty());
EXPECT_FALSE(conn->outstandings.packets.empty());
EXPECT_EQ(
conn->outstandingPackets.back().packet.header.getPacketSequenceNum(),
conn->outstandings.packets.back().packet.header.getPacketSequenceNum(),
currentPacketSeqNum + 1);
EXPECT_TRUE(conn->pendingEvents.setLossDetectionAlarm);
EXPECT_GT(stream1->currentWriteOffset, currentStreamWriteOffset);
@@ -1566,7 +1566,7 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingCryptoData) {
writeCryptoDataProbesToSocketForTest(
*rawSocket, conn, 1, *aead, *headerCipher, getVersion(conn));
EXPECT_LT(currentPacketSeqNum, conn.ackStates.initialAckState.nextPacketNum);
EXPECT_FALSE(conn.outstandingPackets.empty());
EXPECT_FALSE(conn.outstandings.packets.empty());
EXPECT_TRUE(conn.pendingEvents.setLossDetectionAlarm);
EXPECT_GT(cryptoStream->currentWriteOffset, currentStreamWriteOffset);
EXPECT_FALSE(cryptoStream->retransmissionBuffer.empty());
@@ -1599,14 +1599,17 @@ TEST_F(QuicTransportFunctionsTest, ProbingFallbackToPing) {
*aead,
*headerCipher,
getVersion(*conn)));
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandingPackets[0].packet.frames.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
EXPECT_EQ(1, conn->outstandings.packets[0].packet.frames.size());
EXPECT_EQ(
QuicWriteFrame::Type::QuicSimpleFrame_E,
conn->outstandingPackets[0].packet.frames[0].type());
conn->outstandings.packets[0].packet.frames[0].type());
EXPECT_EQ(
QuicSimpleFrame::Type::PingFrame_E,
conn->outstandingPackets[0].packet.frames[0].asQuicSimpleFrame()->type());
conn->outstandings.packets[0]
.packet.frames[0]
.asQuicSimpleFrame()
->type());
}
TEST_F(QuicTransportFunctionsTest, TestCryptoWritingIsHandshakeInOutstanding) {
@@ -1631,7 +1634,7 @@ TEST_F(QuicTransportFunctionsTest, TestCryptoWritingIsHandshakeInOutstanding) {
*conn->initialHeaderCipher,
getVersion(*conn),
conn->transportSettings.writeConnectionDataPacketsLimit));
ASSERT_EQ(1, conn->outstandingPackets.size());
ASSERT_EQ(1, conn->outstandings.packets.size());
EXPECT_TRUE(getFirstOutstandingPacket(*conn, PacketNumberSpace::Initial)
->isHandshake);
}
@@ -1677,7 +1680,7 @@ TEST_F(QuicTransportFunctionsTest, WritePureAckWhenNoWritableBytes) {
getVersion(*conn),
conn->transportSettings.writeConnectionDataPacketsLimit),
0);
EXPECT_EQ(0, conn->outstandingPackets.size());
EXPECT_EQ(0, conn->outstandings.packets.size());
}
TEST_F(QuicTransportFunctionsTest, ShouldWriteDataTest) {
@@ -1926,16 +1929,16 @@ TEST_F(QuicTransportFunctionsTest, HasAppDataToWrite) {
TEST_F(QuicTransportFunctionsTest, UpdateConnectionCloneCounter) {
auto conn = createConn();
ASSERT_EQ(0, conn->outstandingClonedPacketsCount);
ASSERT_EQ(0, conn->outstandings.clonedPacketsCount);
auto packet = buildEmptyPacket(*conn, PacketNumberSpace::AppData);
auto connWindowUpdate =
MaxDataFrame(conn->flowControlState.advertisedMaxOffset);
conn->pendingEvents.connWindowUpdate = true;
packet.packet.frames.emplace_back(connWindowUpdate);
PacketEvent packetEvent = 100;
conn->outstandingPacketEvents.insert(packetEvent);
conn->outstandings.packetEvents.insert(packetEvent);
updateConnection(*conn, packetEvent, packet.packet, TimePoint(), 123);
EXPECT_EQ(1, conn->outstandingClonedPacketsCount);
EXPECT_EQ(1, conn->outstandings.clonedPacketsCount);
}
TEST_F(QuicTransportFunctionsTest, ClearBlockedFromPendingEvents) {
@@ -1948,8 +1951,8 @@ TEST_F(QuicTransportFunctionsTest, ClearBlockedFromPendingEvents) {
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_FALSE(conn->streamManager->hasBlocked());
EXPECT_FALSE(conn->outstandingPackets.empty());
EXPECT_EQ(0, conn->outstandingClonedPacketsCount);
EXPECT_FALSE(conn->outstandings.packets.empty());
EXPECT_EQ(0, conn->outstandings.clonedPacketsCount);
}
TEST_F(QuicTransportFunctionsTest, ClonedBlocked) {
@@ -1959,12 +1962,12 @@ TEST_F(QuicTransportFunctionsTest, ClonedBlocked) {
auto stream = conn->streamManager->createNextBidirectionalStream().value();
StreamDataBlockedFrame blockedFrame(stream->id, 1000);
packet.packet.frames.emplace_back(blockedFrame);
conn->outstandingPacketEvents.insert(packetEvent);
conn->outstandings.packetEvents.insert(packetEvent);
// This shall not crash
updateConnection(
*conn, packetEvent, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_FALSE(conn->outstandingPackets.empty());
EXPECT_EQ(1, conn->outstandingClonedPacketsCount);
EXPECT_FALSE(conn->outstandings.packets.empty());
EXPECT_EQ(1, conn->outstandings.clonedPacketsCount);
}
TEST_F(QuicTransportFunctionsTest, TwoConnWindowUpdateWillCrash) {
@@ -1995,7 +1998,7 @@ TEST_F(QuicTransportFunctionsTest, WriteStreamFrameIsNotPureAck) {
packet.packet.frames.push_back(std::move(writeStreamFrame));
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_FALSE(conn->outstandingPackets.empty());
EXPECT_FALSE(conn->outstandings.packets.empty());
}
TEST_F(QuicTransportFunctionsTest, ClearRstFromPendingEvents) {
@@ -2009,8 +2012,8 @@ TEST_F(QuicTransportFunctionsTest, ClearRstFromPendingEvents) {
updateConnection(
*conn, folly::none, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_TRUE(conn->pendingEvents.resets.empty());
EXPECT_FALSE(conn->outstandingPackets.empty());
EXPECT_EQ(0, conn->outstandingClonedPacketsCount);
EXPECT_FALSE(conn->outstandings.packets.empty());
EXPECT_EQ(0, conn->outstandings.clonedPacketsCount);
}
TEST_F(QuicTransportFunctionsTest, ClonedRst) {
@@ -2021,12 +2024,12 @@ TEST_F(QuicTransportFunctionsTest, ClonedRst) {
RstStreamFrame rstStreamFrame(
stream->id, GenericApplicationErrorCode::UNKNOWN, 0);
packet.packet.frames.emplace_back(std::move(rstStreamFrame));
conn->outstandingPacketEvents.insert(packetEvent);
conn->outstandings.packetEvents.insert(packetEvent);
// This shall not crash
updateConnection(
*conn, packetEvent, packet.packet, TimePoint(), getEncodedSize(packet));
EXPECT_FALSE(conn->outstandingPackets.empty());
EXPECT_EQ(1, conn->outstandingClonedPacketsCount);
EXPECT_FALSE(conn->outstandings.packets.empty());
EXPECT_EQ(1, conn->outstandings.clonedPacketsCount);
}
TEST_F(QuicTransportFunctionsTest, TotalBytesSentUpdate) {
@@ -2046,7 +2049,7 @@ TEST_F(QuicTransportFunctionsTest, TimeoutBasedRetxCountUpdate) {
stream->id, GenericApplicationErrorCode::UNKNOWN, 0);
packet.packet.frames.push_back(rstStreamFrame);
PacketEvent packetEvent = 100;
conn->outstandingPacketEvents.insert(packetEvent);
conn->outstandings.packetEvents.insert(packetEvent);
updateConnection(*conn, packetEvent, packet.packet, TimePoint(), 500);
EXPECT_EQ(247, conn->lossState.timeoutBasedRtxCount);
}
@@ -2214,11 +2217,11 @@ TEST_F(QuicTransportFunctionsTest, ProbeWriteNewFunctionalFrames) {
*headerCipher,
getVersion(*conn),
1 /* limit to 1 packet */);
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandingPackets[1].packet.frames.size());
EXPECT_EQ(2, conn->outstandings.packets.size());
EXPECT_EQ(1, conn->outstandings.packets[1].packet.frames.size());
EXPECT_EQ(
QuicWriteFrame::Type::MaxDataFrame_E,
conn->outstandingPackets[1].packet.frames[0].type());
conn->outstandings.packets[1].packet.frames[0].type());
}
TEST_F(QuicTransportFunctionsTest, WriteWithInplaceBuilder) {
@@ -2375,13 +2378,13 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
conn->transportSettings.writeConnectionDataPacketsLimit + 1);
ASSERT_EQ(0, bufPtr->length());
ASSERT_EQ(0, bufPtr->headroom());
EXPECT_GE(conn->outstandingPackets.size(), 5);
EXPECT_GE(conn->outstandings.packets.size(), 5);
// Make sure there no more new data to write:
StreamFrameScheduler streamScheduler(*conn);
ASSERT_FALSE(streamScheduler.hasPendingData());
// The last packet may not be a full packet
auto lastPacketSize = conn->outstandingPackets.back().encodedSize;
auto lastPacketSize = conn->outstandings.packets.back().encodedSize;
size_t expectedOutstandingPacketsCount = 5;
if (lastPacketSize < conn->udpSendPacketLen) {
expectedOutstandingPacketsCount++;
@@ -2404,7 +2407,7 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
*headerCipher,
getVersion(*conn));
EXPECT_EQ(
conn->outstandingPackets.size(), expectedOutstandingPacketsCount + 1);
conn->outstandings.packets.size(), expectedOutstandingPacketsCount + 1);
EXPECT_EQ(0, bufPtr->length());
EXPECT_EQ(0, bufPtr->headroom());
@@ -2442,14 +2445,15 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
EXPECT_EQ(0, bufPtr->length());
EXPECT_EQ(0, bufPtr->headroom());
EXPECT_EQ(
conn->outstandingPackets.size(), expectedOutstandingPacketsCount + 3);
conn->outstandings.packets.size(), expectedOutstandingPacketsCount + 3);
// Clear out all the small packets:
while (conn->outstandingPackets.back().encodedSize < conn->udpSendPacketLen) {
conn->outstandingPackets.pop_back();
while (conn->outstandings.packets.back().encodedSize <
conn->udpSendPacketLen) {
conn->outstandings.packets.pop_back();
}
ASSERT_FALSE(conn->outstandingPackets.empty());
auto currentOutstandingPackets = conn->outstandingPackets.size();
ASSERT_FALSE(conn->outstandings.packets.empty());
auto currentOutstandingPackets = conn->outstandings.packets.size();
// Clone 2 full size packets
EXPECT_CALL(mockSock, writeGSO(_, _, _))
@@ -2469,7 +2473,7 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingWithInplaceBuilder) {
*aead,
*headerCipher,
getVersion(*conn));
EXPECT_EQ(conn->outstandingPackets.size(), currentOutstandingPackets + 2);
EXPECT_EQ(conn->outstandings.packets.size(), currentOutstandingPackets + 2);
EXPECT_EQ(0, bufPtr->length());
EXPECT_EQ(0, bufPtr->headroom());
}

160
quic/api/test/QuicTransportTest.cpp
View File

@@ -243,7 +243,7 @@ size_t bufLength(
}
void dropPackets(QuicServerConnectionState& conn) {
for (const auto& packet : conn.outstandingPackets) {
for (const auto& packet : conn.outstandings.packets) {
for (const auto& frame : packet.packet.frames) {
const WriteStreamFrame* streamFrame = frame.asWriteStreamFrame();
if (!streamFrame) {
@@ -272,7 +272,7 @@ void dropPackets(QuicServerConnectionState& conn) {
}
}
}
conn.outstandingPackets.clear();
conn.outstandings.packets.clear();
}
// Helper function to verify the data of buffer is written to outstanding
@@ -288,7 +288,7 @@ void verifyCorrectness(
size_t totalLen = 0;
bool finSet = false;
std::vector<uint64_t> offsets;
for (const auto& packet : conn.outstandingPackets) {
for (const auto& packet : conn.outstandings.packets) {
for (const auto& frame : packet.packet.frames) {
auto streamFrame = frame.asWriteStreamFrame();
if (!streamFrame) {
@@ -413,7 +413,7 @@ TEST_F(QuicTransportTest, NotAppLimitedWithNoWritableBytes) {
conn.congestionController = std::move(mockCongestionController);
EXPECT_CALL(*rawCongestionController, getWritableBytes())
.WillRepeatedly(Invoke([&]() {
if (conn.outstandingPackets.empty()) {
if (conn.outstandings.packets.empty()) {
return 5000;
}
return 0;
@@ -512,7 +512,7 @@ TEST_F(QuicTransportTest, WriteLarge) {
transport_->writeChain(stream, buf->clone(), false, false);
loopForWrites();
auto& conn = transport_->getConnectionState();
EXPECT_EQ(NumFullPackets + 1, conn.outstandingPackets.size());
EXPECT_EQ(NumFullPackets + 1, conn.outstandings.packets.size());
verifyCorrectness(conn, 0, stream, *buf);
// Test retransmission
@@ -529,7 +529,7 @@ TEST_F(QuicTransportTest, WriteLarge) {
*headerCipher_,
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(NumFullPackets + 1, conn.outstandingPackets.size());
EXPECT_EQ(NumFullPackets + 1, conn.outstandings.packets.size());
verifyCorrectness(conn, 0, stream, *buf);
EXPECT_EQ(WriteDataReason::NO_WRITE, shouldWriteData(conn));
}
@@ -545,7 +545,7 @@ TEST_F(QuicTransportTest, WriteMultipleTimes) {
conn.streamManager->findStream(stream)->currentWriteOffset;
verifyCorrectness(conn, 0, stream, *buf);
conn.outstandingPackets.clear();
conn.outstandings.packets.clear();
conn.streamManager->findStream(stream)->retransmissionBuffer.clear();
buf = buildRandomInputData(50);
EXPECT_CALL(*socket_, write(_, _)).WillOnce(Invoke(bufLength));
@@ -610,7 +610,7 @@ TEST_F(QuicTransportTest, WriteFlowControl) {
transport_->writeChain(streamId, buf->clone(), false, false);
loopForWrites();
EXPECT_EQ(conn.outstandingPackets.size(), 1);
EXPECT_EQ(conn.outstandings.packets.size(), 1);
auto& packet =
getFirstOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
bool blockedFound = false;
@@ -623,7 +623,7 @@ TEST_F(QuicTransportTest, WriteFlowControl) {
blockedFound = true;
}
EXPECT_TRUE(blockedFound);
conn.outstandingPackets.clear();
conn.outstandings.packets.clear();
// Stream flow control
auto buf1 = buf->clone();
@@ -793,7 +793,7 @@ TEST_F(QuicTransportTest, WriteImmediateAcks) {
*headerCipher_,
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_TRUE(conn.outstandingPackets.empty());
EXPECT_TRUE(conn.outstandings.packets.empty());
EXPECT_EQ(conn.ackStates.appDataAckState.largestAckScheduled, end);
EXPECT_FALSE(conn.ackStates.appDataAckState.needsToSendAckImmediately);
EXPECT_EQ(0, conn.ackStates.appDataAckState.numNonRxPacketsRecvd);
@@ -833,7 +833,7 @@ TEST_F(QuicTransportTest, WritePendingAckIfHavingData) {
// We should write acks if there is data pending
transport_->writeChain(streamId, buf->clone(), true, false);
loopForWrites();
EXPECT_EQ(conn.outstandingPackets.size(), 1);
EXPECT_EQ(conn.outstandings.packets.size(), 1);
auto& packet =
getFirstOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
EXPECT_GE(packet.frames.size(), 2);
@@ -865,7 +865,7 @@ TEST_F(QuicTransportTest, RstStream) {
EXPECT_CALL(*socket_, write(_, _)).WillOnce(Invoke(bufLength));
transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
loopForWrites();
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -901,7 +901,7 @@ TEST_F(QuicTransportTest, StopSending) {
EXPECT_CALL(*socket_, write(_, _)).WillOnce(Invoke(bufLength));
transport_->stopSending(streamId, GenericApplicationErrorCode::UNKNOWN);
loopForWrites();
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -943,7 +943,7 @@ TEST_F(QuicTransportTest, SendPathChallenge) {
EXPECT_EQ(conn.outstandingPathValidation, pathChallenge);
EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -984,7 +984,7 @@ TEST_F(QuicTransportTest, PathValidationTimeoutExpired) {
EXPECT_EQ(conn.outstandingPathValidation, pathChallenge);
EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
transport_->getPathValidationTimeout().cancelTimeout();
transport_->getPathValidationTimeout().timeoutExpired();
@@ -1012,7 +1012,7 @@ TEST_F(QuicTransportTest, SendPathValidationWhileThereIsOutstandingOne) {
EXPECT_EQ(conn.outstandingPathValidation, pathChallenge);
EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
PathChallengeFrame pathChallenge2(456);
transport_->getPathValidationTimeout().cancelTimeout();
@@ -1029,14 +1029,14 @@ TEST_F(QuicTransportTest, SendPathValidationWhileThereIsOutstandingOne) {
EXPECT_EQ(conn.outstandingPathValidation, pathChallenge2);
EXPECT_TRUE(transport_->getPathValidationTimeout().isScheduled());
EXPECT_EQ(2, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(2, transport_->getConnectionState().outstandings.packets.size());
}
TEST_F(QuicTransportTest, ClonePathChallenge) {
auto& conn = transport_->getConnectionState();
// knock every handshake outstanding packets out
conn.outstandingHandshakePacketsCount = 0;
conn.outstandingPackets.clear();
conn.outstandings.handshakePacketsCount = 0;
conn.outstandings.packets.clear();
for (auto& t : conn.lossState.lossTimes) {
t.reset();
}
@@ -1048,20 +1048,20 @@ TEST_F(QuicTransportTest, ClonePathChallenge) {
transport_->updateWriteLooper(true);
loopForWrites();
EXPECT_EQ(conn.outstandingPackets.size(), 1);
EXPECT_EQ(conn.outstandings.packets.size(), 1);
auto numPathChallengePackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
EXPECT_EQ(numPathChallengePackets, 1);
// Force a timeout with no data so that it clones the packet
transport_->lossTimeout().timeoutExpired();
// On PTO, endpoint sends 2 probing packets, thus 1+2=3
EXPECT_EQ(conn.outstandingPackets.size(), 3);
EXPECT_EQ(conn.outstandings.packets.size(), 3);
numPathChallengePackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
EXPECT_EQ(numPathChallengePackets, 3);
@@ -1070,8 +1070,8 @@ TEST_F(QuicTransportTest, ClonePathChallenge) {
TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
auto& conn = transport_->getConnectionState();
// knock every handshake outstanding packets out
conn.outstandingHandshakePacketsCount = 0;
conn.outstandingPackets.clear();
conn.outstandings.handshakePacketsCount = 0;
conn.outstandings.packets.clear();
for (auto& t : conn.lossState.lossTimes) {
t.reset();
}
@@ -1084,8 +1084,8 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
loopForWrites();
auto numPathChallengePackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
EXPECT_EQ(numPathChallengePackets, 1);
@@ -1097,8 +1097,8 @@ TEST_F(QuicTransportTest, OnlyClonePathValidationIfOutstanding) {
// Force a timeout with no data so that it clones the packet
transport_->lossTimeout().timeoutExpired();
numPathChallengePackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::PathChallengeFrame_E>());
EXPECT_EQ(numPathChallengePackets, 1);
}
@@ -1113,7 +1113,7 @@ TEST_F(QuicTransportTest, ResendPathChallengeOnLoss) {
transport_->updateWriteLooper(true);
loopForWrites();
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1134,7 +1134,7 @@ TEST_F(QuicTransportTest, DoNotResendLostPathChallengeIfNotOutstanding) {
transport_->updateWriteLooper(true);
loopForWrites();
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1160,7 +1160,7 @@ TEST_F(QuicTransportTest, SendPathResponse) {
loopForWrites();
EXPECT_EQ(conn.pendingEvents.frames.size(), 0);
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto packet =
getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
bool foundPathResponse = false;
@@ -1184,7 +1184,7 @@ TEST_F(QuicTransportTest, CloneAfterRecvReset) {
auto streamId = transport_->createBidirectionalStream().value();
transport_->writeChain(streamId, IOBuf::create(0), true, false);
loopForWrites();
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto stream = conn.streamManager->getStream(streamId);
EXPECT_EQ(1, stream->retransmissionBuffer.size());
EXPECT_EQ(0, stream->retransmissionBuffer.at(0)->data.chainLength());
@@ -1201,10 +1201,10 @@ TEST_F(QuicTransportTest, CloneAfterRecvReset) {
// the future, thus the EXPECT were written with LT and LE. But it will clone
// for sure and we shouldn't crash.
transport_->lossTimeout().timeoutExpired();
EXPECT_LT(1, conn.outstandingPackets.size());
EXPECT_LT(1, conn.outstandings.packets.size());
size_t cloneCounter = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
[](const auto& packet) { return packet.associatedEvent.hasValue(); });
EXPECT_LE(1, cloneCounter);
}
@@ -1212,8 +1212,8 @@ TEST_F(QuicTransportTest, CloneAfterRecvReset) {
TEST_F(QuicTransportTest, ClonePathResponse) {
auto& conn = transport_->getConnectionState();
// knock every handshake outstanding packets out
conn.outstandingHandshakePacketsCount = 0;
conn.outstandingPackets.clear();
conn.outstandings.handshakePacketsCount = 0;
conn.outstandings.packets.clear();
for (auto& t : conn.lossState.lossTimes) {
t.reset();
}
@@ -1227,16 +1227,16 @@ TEST_F(QuicTransportTest, ClonePathResponse) {
EXPECT_EQ(conn.pendingEvents.frames.size(), 0);
auto numPathResponsePackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::PathResponseFrame_E>());
EXPECT_EQ(numPathResponsePackets, 1);
// Force a timeout with no data so that it clones the packet
transport_->lossTimeout().timeoutExpired();
numPathResponsePackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::PathResponseFrame_E>());
EXPECT_EQ(numPathResponsePackets, 1);
}
@@ -1252,7 +1252,7 @@ TEST_F(QuicTransportTest, DoNotResendPathResponseOnLoss) {
loopForWrites();
EXPECT_EQ(conn.pendingEvents.frames.size(), 0);
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto packet =
getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
@@ -1270,7 +1270,7 @@ TEST_F(QuicTransportTest, SendNewConnectionIdFrame) {
loopForWrites();
EXPECT_TRUE(conn.pendingEvents.frames.empty());
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1295,8 +1295,8 @@ TEST_F(QuicTransportTest, SendNewConnectionIdFrame) {
TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) {
auto& conn = transport_->getConnectionState();
// knock every handshake outstanding packets out
conn.outstandingHandshakePacketsCount = 0;
conn.outstandingPackets.clear();
conn.outstandings.handshakePacketsCount = 0;
conn.outstandings.packets.clear();
for (auto& t : conn.lossState.lossTimes) {
t.reset();
}
@@ -1307,20 +1307,20 @@ TEST_F(QuicTransportTest, CloneNewConnectionIdFrame) {
transport_->updateWriteLooper(true);
loopForWrites();
EXPECT_EQ(conn.outstandingPackets.size(), 1);
EXPECT_EQ(conn.outstandings.packets.size(), 1);
auto numNewConnIdPackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::NewConnectionIdFrame_E>());
EXPECT_EQ(numNewConnIdPackets, 1);
// Force a timeout with no data so that it clones the packet
transport_->lossTimeout().timeoutExpired();
// On PTO, endpoint sends 2 probing packets, thus 1+2=3
EXPECT_EQ(conn.outstandingPackets.size(), 3);
EXPECT_EQ(conn.outstandings.packets.size(), 3);
numNewConnIdPackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::NewConnectionIdFrame_E>());
EXPECT_EQ(numNewConnIdPackets, 3);
}
@@ -1356,7 +1356,7 @@ TEST_F(QuicTransportTest, BusyWriteLoopDetection) {
EXPECT_EQ(WriteDataReason::STREAM, conn.writeDebugState.writeDataReason);
EXPECT_CALL(*socket_, write(_, _)).WillOnce(Return(1000));
loopForWrites();
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
EXPECT_EQ(0, conn.writeDebugState.currentEmptyLoopCount);
// Queue a window update for a stream doesn't exist
@@ -1371,7 +1371,7 @@ TEST_F(QuicTransportTest, BusyWriteLoopDetection) {
onSuspiciousWriteLoops(1, WriteDataReason::STREAM_WINDOW_UPDATE, _, _))
.Times(1);
loopForWrites();
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
EXPECT_EQ(1, conn.writeDebugState.currentEmptyLoopCount);
transport_->close(folly::none);
@@ -1386,7 +1386,7 @@ TEST_F(QuicTransportTest, ResendNewConnectionIdOnLoss) {
transport_->updateWriteLooper(true);
loopForWrites();
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1410,7 +1410,7 @@ TEST_F(QuicTransportTest, SendRetireConnectionIdFrame) {
loopForWrites();
EXPECT_TRUE(conn.pendingEvents.frames.empty());
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1435,8 +1435,8 @@ TEST_F(QuicTransportTest, SendRetireConnectionIdFrame) {
TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
auto& conn = transport_->getConnectionState();
// knock every handshake outstanding packets out
conn.outstandingHandshakePacketsCount = 0;
conn.outstandingPackets.clear();
conn.outstandings.handshakePacketsCount = 0;
conn.outstandings.packets.clear();
for (auto& t : conn.lossState.lossTimes) {
t.reset();
}
@@ -1446,10 +1446,10 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
transport_->updateWriteLooper(true);
loopForWrites();
EXPECT_EQ(conn.outstandingPackets.size(), 1);
EXPECT_EQ(conn.outstandings.packets.size(), 1);
auto numRetireConnIdPackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<
QuicSimpleFrame::Type::RetireConnectionIdFrame_E>());
EXPECT_EQ(numRetireConnIdPackets, 1);
@@ -1457,10 +1457,10 @@ TEST_F(QuicTransportTest, CloneRetireConnectionIdFrame) {
// Force a timeout with no data so that it clones the packet
transport_->lossTimeout().timeoutExpired();
// On PTO, endpoint sends 2 probing packets, thus 1+2=3
EXPECT_EQ(conn.outstandingPackets.size(), 3);
EXPECT_EQ(conn.outstandings.packets.size(), 3);
numRetireConnIdPackets = std::count_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
findFrameInPacketFunc<
QuicSimpleFrame::Type::RetireConnectionIdFrame_E>());
EXPECT_EQ(numRetireConnIdPackets, 3);
@@ -1474,7 +1474,7 @@ TEST_F(QuicTransportTest, ResendRetireConnectionIdOnLoss) {
transport_->updateWriteLooper(true);
loopForWrites();
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1534,7 +1534,7 @@ TEST_F(QuicTransportTest, RstWrittenStream) {
transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
loopForWrites();
// 2 packets are outstanding: one for Stream frame one for RstStream frame:
EXPECT_EQ(2, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(2, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1568,7 +1568,7 @@ TEST_F(QuicTransportTest, RstStreamUDPWriteFailNonFatal) {
transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
loopForWrites();
EXPECT_EQ(1, transport_->getConnectionState().outstandingPackets.size());
EXPECT_EQ(1, transport_->getConnectionState().outstandings.packets.size());
auto packet =
getLastOutstandingPacket(
transport_->getConnectionState(), PacketNumberSpace::AppData)
@@ -1605,7 +1605,7 @@ TEST_F(QuicTransportTest, RstStreamUDPWriteFailFatal) {
.WillRepeatedly(SetErrnoAndReturn(EBADF, -1));
transport_->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
loopForWrites();
EXPECT_TRUE(transport_->getConnectionState().outstandingPackets.empty());
EXPECT_TRUE(transport_->getConnectionState().outstandings.packets.empty());
// Streams should be empty now since the connection will be closed.
EXPECT_EQ(transport_->getConnectionState().streamManager->streamCount(), 0);
@@ -1640,7 +1640,7 @@ TEST_F(QuicTransportTest, WriteAfterSendRst) {
// only 2 packets are outstanding: one for Stream frame one for RstStream
// frame. The 2nd writeChain won't write anything.
EXPECT_EQ(2, conn.outstandingPackets.size());
EXPECT_EQ(2, conn.outstandings.packets.size());
auto packet =
getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
EXPECT_GE(packet.frames.size(), 1);
@@ -1720,7 +1720,7 @@ TEST_F(QuicTransportTest, WriteWindowUpdate) {
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, res); // Write one packet out
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto packet =
getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
EXPECT_GE(packet.frames.size(), 1);
@@ -1737,7 +1737,7 @@ TEST_F(QuicTransportTest, WriteWindowUpdate) {
EXPECT_TRUE(connWindowFound);
EXPECT_EQ(conn.flowControlState.advertisedMaxOffset, 100);
conn.outstandingPackets.clear();
conn.outstandings.packets.clear();
auto stream = transport_->createBidirectionalStream().value();
auto streamState = conn.streamManager->getStream(stream);
@@ -1756,7 +1756,7 @@ TEST_F(QuicTransportTest, WriteWindowUpdate) {
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, res); // Write one packet out
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto packet1 =
getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
const MaxStreamDataFrame* streamWindowUpdate =
@@ -2353,14 +2353,14 @@ TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
*headerCipher_,
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto& packet = *getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
EXPECT_EQ(1, packet.packet.frames.size());
auto& frame = packet.packet.frames.front();
const WriteStreamFrame* streamFrame = frame.asWriteStreamFrame();
EXPECT_TRUE(streamFrame);
EXPECT_EQ(streamFrame->streamId, s1);
conn.outstandingPackets.clear();
conn.outstandings.packets.clear();
// Start from stream2 instead of stream1
conn.schedulingState.nextScheduledStream = s2;
@@ -2376,14 +2376,14 @@ TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
*headerCipher_,
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto& packet2 = *getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
EXPECT_EQ(1, packet2.packet.frames.size());
auto& frame2 = packet2.packet.frames.front();
const WriteStreamFrame* streamFrame2 = frame2.asWriteStreamFrame();
EXPECT_TRUE(streamFrame2);
EXPECT_EQ(streamFrame2->streamId, s2);
conn.outstandingPackets.clear();
conn.outstandings.packets.clear();
// Test wrap around
conn.schedulingState.nextScheduledStream = s2;
@@ -2398,7 +2398,7 @@ TEST_F(QuicTransportTest, WriteStreamFromMiddleOfMap) {
*headerCipher_,
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
auto& packet3 = *getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
EXPECT_EQ(2, packet3.packet.frames.size());
auto& frame3 = packet3.packet.frames.front();
@@ -2424,7 +2424,7 @@ TEST_F(QuicTransportTest, NoStream) {
*headerCipher_,
transport_->getVersion(),
conn.transportSettings.writeConnectionDataPacketsLimit);
EXPECT_TRUE(conn.outstandingPackets.empty());
EXPECT_TRUE(conn.outstandings.packets.empty());
}
TEST_F(QuicTransportTest, CancelAckTimeout) {

10
quic/codec/QuicPacketRebuilder.cpp
View File

@@ -25,16 +25,16 @@ uint64_t PacketRebuilder::getHeaderBytes() const {
PacketEvent PacketRebuilder::cloneOutstandingPacket(OutstandingPacket& packet) {
// Either the packet has never been cloned before, or it's associatedEvent is
// still in the outstandingPacketEvents set.
// still in the outstandings.packetEvents set.
DCHECK(
!packet.associatedEvent ||
conn_.outstandingPacketEvents.count(*packet.associatedEvent));
conn_.outstandings.packetEvents.count(*packet.associatedEvent));
if (!packet.associatedEvent) {
auto packetNum = packet.packet.header.getPacketSequenceNum();
DCHECK(!conn_.outstandingPacketEvents.count(packetNum));
DCHECK(!conn_.outstandings.packetEvents.count(packetNum));
packet.associatedEvent = packetNum;
conn_.outstandingPacketEvents.insert(packetNum);
++conn_.outstandingClonedPacketsCount;
conn_.outstandings.packetEvents.insert(packetNum);
++conn_.outstandings.clonedPacketsCount;
}
return *packet.associatedEvent;
}

2
quic/codec/QuicPacketRebuilder.h
View File

@@ -38,7 +38,7 @@ class PacketRebuilder {
/**
* A helper function that takes a OutstandingPacket that's not processed, and
* return its associatedEvent. If this packet has never been cloned, then
* create the associatedEvent and add it into outstandingPacketEvents first.
* create the associatedEvent and add it into outstandings.packetEvents first.
*/
PacketEvent cloneOutstandingPacket(OutstandingPacket& packet);

2
quic/codec/test/QuicPacketRebuilderTest.cpp
View File

@@ -448,7 +448,7 @@ TEST_F(QuicPacketRebuilderTest, CloneCounter) {
PacketRebuilder rebuilder(regularBuilder2, conn);
rebuilder.rebuildFromPacket(outstandingPacket);
EXPECT_TRUE(outstandingPacket.associatedEvent.has_value());
EXPECT_EQ(1, conn.outstandingClonedPacketsCount);
EXPECT_EQ(1, conn.outstandings.clonedPacketsCount);
}
TEST_F(QuicPacketRebuilderTest, LastStreamFrameSkipLen) {

4
quic/common/test/TestUtils.cpp
View File

@@ -45,7 +45,7 @@ const RegularQuicWritePacket& writeQuicPacket(
version,
conn.transportSettings.writeConnectionDataPacketsLimit);
CHECK(
conn.outstandingPackets.rend() !=
conn.outstandings.packets.rend() !=
getLastOutstandingPacket(conn, PacketNumberSpace::AppData));
return getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet;
}
@@ -69,7 +69,7 @@ PacketNum rstStreamAndSendPacket(
version,
conn.transportSettings.writeConnectionDataPacketsLimit);
for (const auto& packet : conn.outstandingPackets) {
for (const auto& packet : conn.outstandings.packets) {
for (const auto& frame : packet.packet.frames) {
auto rstFrame = frame.asRstStreamFrame();
if (!rstFrame) {

2
quic/common/test/TestUtils.h
View File

@@ -202,7 +202,7 @@ OutstandingPacket* findOutstandingPacket(
}
return nullptr;
};
return helper(conn.outstandingPackets);
return helper(conn.outstandings.packets);
}
// Helper function to generate a buffer containing random data of given length

6
quic/congestion_control/Bandwidth.h
View File

@@ -27,14 +27,12 @@ struct Bandwidth {
UnitType unitType{UnitType::BYTES};
explicit Bandwidth()
: units(0),
interval(std::chrono::microseconds::zero()) {}
: units(0), interval(std::chrono::microseconds::zero()) {}
explicit Bandwidth(
uint64_t unitsDelievered,
std::chrono::microseconds deliveryInterval)
: units(unitsDelievered),
interval(deliveryInterval) {}
: units(unitsDelievered), interval(deliveryInterval) {}
explicit Bandwidth(
uint64_t unitsDelievered,

2
quic/congestion_control/test/BbrTest.cpp
View File

@@ -548,7 +548,7 @@ TEST_F(BbrTest, BytesCounting) {
PacketNum packetNum = 0;
auto packet = makeTestingWritePacket(packetNum, 1200, 1200);
conn.outstandingPackets.push_back(packet);
conn.outstandings.packets.push_back(packet);
ReadAckFrame ackFrame;
ackFrame.largestAcked = packetNum;
ackFrame.ackBlocks.emplace_back(packetNum, packetNum);

1
quic/congestion_control/test/CongestionControlFunctionsTest.cpp
View File

@@ -72,6 +72,5 @@ TEST_F(CongestionControlFunctionsTest, RttSmallerThanInterval) {
conn.transportSettings.writeConnectionDataPacketsLimit, result.burstSize);
}
} // namespace test
} // namespace quic

18
quic/fizz/client/test/QuicClientTransportTest.cpp
View File

@@ -3474,7 +3474,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) {
client->writeChain(streamId, expected->clone(), true, false);
loopForWrites();
// ack all the packets
ASSERT_FALSE(client->getConn().outstandingPackets.empty());
ASSERT_FALSE(client->getConn().outstandings.packets.empty());
AckBlocks acks;
auto start = getFirstOutstandingPacket(
@@ -3549,7 +3549,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithNoStreamPending) {
loopForWrites();
// ack all the packets
ASSERT_FALSE(client->getConn().outstandingPackets.empty());
ASSERT_FALSE(client->getConn().outstandings.packets.empty());
AckBlocks acks;
auto start = getFirstOutstandingPacket(
@@ -3961,7 +3961,7 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimerNotResetOnWritingOldData) {
TEST_F(QuicClientTransportAfterStartTest, IdleTimerResetNoOutstandingPackets) {
// This will clear out all the outstanding packets
AckBlocks sentPackets;
for (auto& packet : client->getNonConstConn().outstandingPackets) {
for (auto& packet : client->getNonConstConn().outstandings.packets) {
auto packetNum = packet.packet.header.getPacketSequenceNum();
sentPackets.insert(packetNum);
}
@@ -3974,9 +3974,9 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimerResetNoOutstandingPackets) {
// Clear out all the outstanding packets to simulate quiescent state.
client->getNonConstConn().receivedNewPacketBeforeWrite = false;
client->getNonConstConn().outstandingPackets.clear();
client->getNonConstConn().outstandingHandshakePacketsCount = 0;
client->getNonConstConn().outstandingClonedPacketsCount = 0;
client->getNonConstConn().outstandings.packets.clear();
client->getNonConstConn().outstandings.handshakePacketsCount = 0;
client->getNonConstConn().outstandings.clonedPacketsCount = 0;
client->idleTimeout().cancelTimeout();
auto streamId = client->createBidirectionalStream().value();
auto expected = folly::IOBuf::copyBuffer("hello");
@@ -4723,7 +4723,7 @@ TEST_F(QuicClientTransportAfterStartTest, ResetClearsPendingLoss) {
};
client->writeChain(streamId, IOBuf::copyBuffer("hello"), true, false);
loopForWrites();
ASSERT_FALSE(client->getConn().outstandingPackets.empty());
ASSERT_FALSE(client->getConn().outstandings.packets.empty());
RegularQuicWritePacket* forceLossPacket =
CHECK_NOTNULL(findPacketWithStream(client->getNonConstConn(), streamId));
@@ -4748,7 +4748,7 @@ TEST_F(QuicClientTransportAfterStartTest, LossAfterResetStream) {
};
client->writeChain(streamId, IOBuf::copyBuffer("hello"), true, false);
loopForWrites();
ASSERT_FALSE(client->getConn().outstandingPackets.empty());
ASSERT_FALSE(client->getConn().outstandings.packets.empty());
client->resetStream(streamId, GenericApplicationErrorCode::UNKNOWN);
@@ -5367,7 +5367,7 @@ class QuicZeroRttClientTest : public QuicClientTransportAfterStartTestBase {
}
bool zeroRttPacketsOutstanding() {
for (auto& packet : client->getNonConstConn().outstandingPackets) {
for (auto& packet : client->getNonConstConn().outstandings.packets) {
bool isZeroRtt =
packet.packet.header.getProtectionType() == ProtectionType::ZeroRtt;
if (isZeroRtt) {

4
quic/loss/QuicLossFunctions.cpp
View File

@@ -38,7 +38,7 @@ void onPTOAlarm(QuicConnectionStateBase& conn) {
conn,
conn.lossState.largestSent.value_or(0),
conn.lossState.ptoCount,
(uint64_t)conn.outstandingPackets.size());
(uint64_t)conn.outstandings.packets.size());
QUIC_STATS(conn.statsCallback, onPTO);
conn.lossState.ptoCount++;
conn.lossState.totalPTOCount++;
@@ -46,7 +46,7 @@ void onPTOAlarm(QuicConnectionStateBase& conn) {
conn.qLogger->addLossAlarm(
conn.lossState.largestSent.value_or(0),
conn.lossState.ptoCount,
(uint64_t)conn.outstandingPackets.size(),
(uint64_t)conn.outstandings.packets.size(),
kPtoAlarm);
}
if (conn.lossState.ptoCount == conn.transportSettings.maxNumPTOs) {

92
quic/loss/QuicLossFunctions.h
View File

@@ -77,7 +77,7 @@ calculateAlarmDuration(const QuicConnectionStateBase& conn) {
alarmDuration = 0us;
}
alarmMethod = LossState::AlarmMethod::EarlyRetransmitOrReordering;
} else if (conn.outstandingHandshakePacketsCount > 0) {
} else if (conn.outstandings.handshakePacketsCount > 0) {
if (conn.lossState.srtt == 0us) {
alarmDuration = conn.transportSettings.initialRtt * 2;
} else {
@@ -106,7 +106,7 @@ calculateAlarmDuration(const QuicConnectionStateBase& conn) {
lastSentPacketTime + alarmDuration - now);
} else {
auto lastSentPacketNum =
conn.outstandingPackets.back().packet.header.getPacketSequenceNum();
conn.outstandings.packets.back().packet.header.getPacketSequenceNum();
VLOG(10) << __func__ << " alarm already due method=" << *alarmMethod
<< " lastSentPacketNum=" << lastSentPacketNum
<< " lastSentPacketTime="
@@ -138,7 +138,7 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
*/
bool hasDataToWrite = hasAckDataToWrite(conn) ||
(hasNonAckDataToWrite(conn) != WriteDataReason::NO_WRITE);
auto totalPacketsOutstanding = conn.outstandingPackets.size();
auto totalPacketsOutstanding = conn.outstandings.packets.size();
/*
* We have this condition to disambiguate the case where we have.
* (1) All outstanding packets that are clones that are processed and there
@@ -151,11 +151,11 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
* write them since we could be blocked by cwnd. So we must set the loss timer
* so that we can write this data with the slack packet space for the clones.
*/
if (!hasDataToWrite && conn.outstandingPacketEvents.empty() &&
totalPacketsOutstanding == conn.outstandingClonedPacketsCount) {
if (!hasDataToWrite && conn.outstandings.packetEvents.empty() &&
totalPacketsOutstanding == conn.outstandings.clonedPacketsCount) {
VLOG(10) << __func__ << " unset alarm pure ack or processed packets only"
<< " outstanding=" << totalPacketsOutstanding
<< " handshakePackets=" << conn.outstandingHandshakePacketsCount
<< " handshakePackets=" << conn.outstandings.handshakePacketsCount
<< " " << conn;
conn.pendingEvents.setLossDetectionAlarm = false;
timeout.cancelLossTimeout();
@@ -165,8 +165,8 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
VLOG_IF(10, !timeout.isLossTimeoutScheduled())
<< __func__ << " alarm not scheduled"
<< " outstanding=" << totalPacketsOutstanding
<< " handshakePackets=" << conn.outstandingHandshakePacketsCount << " "
<< nodeToString(conn.nodeType) << " " << conn;
<< " handshakePackets=" << conn.outstandings.handshakePacketsCount
<< " " << nodeToString(conn.nodeType) << " " << conn;
return;
}
timeout.cancelLossTimeout();
@@ -176,7 +176,7 @@ void setLossDetectionAlarm(QuicConnectionStateBase& conn, Timeout& timeout) {
<< " alarm=" << alarmDuration.first.count() << "ms"
<< " method=" << conn.lossState.currentAlarmMethod
<< " outstanding=" << totalPacketsOutstanding
<< " handshakePackets=" << conn.outstandingHandshakePacketsCount
<< " handshakePackets=" << conn.outstandings.handshakePacketsCount
<< " " << nodeToString(conn.nodeType) << " " << conn;
timeout.scheduleLossTimeout(alarmDuration.first);
conn.pendingEvents.setLossDetectionAlarm = false;
@@ -198,7 +198,7 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
std::max(conn.lossState.srtt, conn.lossState.lrtt) *
conn.transportSettings.timeReorderingThreshDividend /
conn.transportSettings.timeReorderingThreshDivisor;
VLOG(10) << __func__ << " outstanding=" << conn.outstandingPackets.size()
VLOG(10) << __func__ << " outstanding=" << conn.outstandings.packets.size()
<< " largestAcked=" << largestAcked.value_or(0)
<< " delayUntilLost=" << delayUntilLost.count() << "us"
<< " " << conn;
@@ -206,7 +206,7 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
// Note that time based loss detection is also within the same PNSpace.
auto iter = getFirstOutstandingPacket(conn, pnSpace);
bool shouldSetTimer = false;
while (iter != conn.outstandingPackets.end()) {
while (iter != conn.outstandings.packets.end()) {
auto& pkt = *iter;
auto currentPacketNum = pkt.packet.header.getPacketSequenceNum();
if (!largestAcked.has_value() || currentPacketNum >= *largestAcked) {
@@ -228,40 +228,40 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
}
lossEvent.addLostPacket(pkt);
if (pkt.associatedEvent) {
DCHECK_GT(conn.outstandingClonedPacketsCount, 0);
--conn.outstandingClonedPacketsCount;
DCHECK_GT(conn.outstandings.clonedPacketsCount, 0);
--conn.outstandings.clonedPacketsCount;
}
// Invoke LossVisitor if the packet doesn't have a associated PacketEvent;
// or if the PacketEvent is present in conn.outstandingPacketEvents.
// or if the PacketEvent is present in conn.outstandings.packetEvents.
bool processed = pkt.associatedEvent &&
!conn.outstandingPacketEvents.count(*pkt.associatedEvent);
!conn.outstandings.packetEvents.count(*pkt.associatedEvent);
lossVisitor(conn, pkt.packet, processed, currentPacketNum);
// Remove the PacketEvent from the outstandingPacketEvents set
// Remove the PacketEvent from the outstandings.packetEvents set
if (pkt.associatedEvent) {
conn.outstandingPacketEvents.erase(*pkt.associatedEvent);
conn.outstandings.packetEvents.erase(*pkt.associatedEvent);
}
if (pkt.isHandshake) {
DCHECK(conn.outstandingHandshakePacketsCount);
--conn.outstandingHandshakePacketsCount;
DCHECK(conn.outstandings.handshakePacketsCount);
--conn.outstandings.handshakePacketsCount;
}
VLOG(10) << __func__ << " lost packetNum=" << currentPacketNum
<< " handshake=" << pkt.isHandshake << " " << conn;
iter = conn.outstandingPackets.erase(iter);
iter = conn.outstandings.packets.erase(iter);
}
auto earliest = getFirstOutstandingPacket(conn, pnSpace);
for (; earliest != conn.outstandingPackets.end();
for (; earliest != conn.outstandings.packets.end();
earliest = getNextOutstandingPacket(conn, pnSpace, earliest + 1)) {
if (!earliest->associatedEvent ||
conn.outstandingPacketEvents.count(*earliest->associatedEvent)) {
conn.outstandings.packetEvents.count(*earliest->associatedEvent)) {
break;
}
}
if (shouldSetTimer && earliest != conn.outstandingPackets.end()) {
if (shouldSetTimer && earliest != conn.outstandings.packets.end()) {
// We are eligible to set a loss timer and there are a few packets which
// are unacked, so we can set the early retransmit timer for them.
VLOG(10) << __func__ << " early retransmit timer outstanding="
<< conn.outstandingPackets.empty() << " delayUntilLost"
<< conn.outstandings.packets.empty() << " delayUntilLost"
<< delayUntilLost.count() << "us"
<< " " << conn;
getLossTime(conn, pnSpace) = delayUntilLost + earliest->time;
@@ -308,18 +308,18 @@ void onHandshakeAlarm(
conn,
conn.lossState.largestSent.value_or(0),
conn.lossState.handshakeAlarmCount,
(uint64_t)conn.outstandingHandshakePacketsCount,
(uint64_t)conn.outstandingPackets.size());
(uint64_t)conn.outstandings.handshakePacketsCount,
(uint64_t)conn.outstandings.packets.size());
if (conn.qLogger) {
conn.qLogger->addLossAlarm(
conn.lossState.largestSent.value_or(0),
conn.lossState.handshakeAlarmCount,
(uint64_t)conn.outstandingPackets.size(),
(uint64_t)conn.outstandings.packets.size(),
kHandshakeAlarm);
}
CongestionController::LossEvent lossEvent(ClockType::now());
auto iter = conn.outstandingPackets.begin();
while (iter != conn.outstandingPackets.end()) {
auto iter = conn.outstandings.packets.begin();
while (iter != conn.outstandings.packets.end()) {
// the word "handshake" in our code base is unfortunately overloaded.
if (iter->isHandshake) {
auto& packet = *iter;
@@ -329,11 +329,11 @@ void onHandshakeAlarm(
<< " packetNumSpace=" << currentPacketNumSpace << " " << conn;
lossEvent.addLostPacket(std::move(packet));
lossVisitor(conn, packet.packet, false, currentPacketNum);
DCHECK(conn.outstandingHandshakePacketsCount);
--conn.outstandingHandshakePacketsCount;
DCHECK(conn.outstandings.handshakePacketsCount);
--conn.outstandings.handshakePacketsCount;
++conn.lossState.timeoutBasedRtxCount;
++conn.lossState.rtxCount;
iter = conn.outstandingPackets.erase(iter);
iter = conn.outstandings.packets.erase(iter);
} else {
iter++;
}
@@ -356,7 +356,7 @@ void onLossDetectionAlarm(
QuicConnectionStateBase& conn,
const LossVisitor& lossVisitor) {
auto now = ClockType::now();
if (conn.outstandingPackets.empty()) {
if (conn.outstandings.packets.empty()) {
VLOG(10) << "Transmission alarm fired with no outstanding packets " << conn;
return;
}
@@ -385,11 +385,11 @@ void onLossDetectionAlarm(
} else {
onPTOAlarm(conn);
}
conn.pendingEvents.setLossDetectionAlarm = !conn.outstandingPackets.empty();
conn.pendingEvents.setLossDetectionAlarm = !conn.outstandings.packets.empty();
VLOG(10) << __func__ << " setLossDetectionAlarm="
<< conn.pendingEvents.setLossDetectionAlarm
<< " outstanding=" << conn.outstandingPackets.size()
<< " handshakePackets=" << conn.outstandingHandshakePacketsCount
<< " outstanding=" << conn.outstandings.packets.size()
<< " handshakePackets=" << conn.outstandings.handshakePacketsCount
<< " " << conn;
}
@@ -426,13 +426,13 @@ folly::Optional<CongestionController::LossEvent> handleAckForLoss(
lossVisitor,
ack.ackTime,
pnSpace);
conn.pendingEvents.setLossDetectionAlarm = !conn.outstandingPackets.empty();
conn.pendingEvents.setLossDetectionAlarm = !conn.outstandings.packets.empty();
VLOG(10) << __func__
<< " largestAckedInPacket=" << ack.largestAckedPacket.value_or(0)
<< " setLossDetectionAlarm="
<< conn.pendingEvents.setLossDetectionAlarm
<< " outstanding=" << conn.outstandingPackets.size()
<< " handshakePackets=" << conn.outstandingHandshakePacketsCount
<< " outstanding=" << conn.outstandings.packets.size()
<< " handshakePackets=" << conn.outstandings.handshakePacketsCount
<< " " << conn;
return lossEvent;
}
@@ -446,7 +446,7 @@ void markZeroRttPacketsLost(
const LossVisitor& lossVisitor) {
CongestionController::LossEvent lossEvent(ClockType::now());
auto iter = getFirstOutstandingPacket(conn, PacketNumberSpace::AppData);
while (iter != conn.outstandingPackets.end()) {
while (iter != conn.outstandings.packets.end()) {
DCHECK_EQ(
iter->packet.header.getPacketNumberSpace(), PacketNumberSpace::AppData);
auto isZeroRttPacket =
@@ -456,16 +456,16 @@ void markZeroRttPacketsLost(
DCHECK(!pkt.isHandshake);
auto currentPacketNum = pkt.packet.header.getPacketSequenceNum();
bool processed = pkt.associatedEvent &&
!conn.outstandingPacketEvents.count(*pkt.associatedEvent);
!conn.outstandings.packetEvents.count(*pkt.associatedEvent);
lossVisitor(conn, pkt.packet, processed, currentPacketNum);
// Remove the PacketEvent from the outstandingPacketEvents set
// Remove the PacketEvent from the outstandings.packetEvents set
if (pkt.associatedEvent) {
conn.outstandingPacketEvents.erase(*pkt.associatedEvent);
DCHECK_GT(conn.outstandingClonedPacketsCount, 0);
--conn.outstandingClonedPacketsCount;
conn.outstandings.packetEvents.erase(*pkt.associatedEvent);
DCHECK_GT(conn.outstandings.clonedPacketsCount, 0);
--conn.outstandings.clonedPacketsCount;
}
lossEvent.addLostPacket(pkt);
iter = conn.outstandingPackets.erase(iter);
iter = conn.outstandings.packets.erase(iter);
iter = getNextOutstandingPacket(conn, PacketNumberSpace::AppData, iter);
} else {
iter =

142
quic/loss/test/QuicLossFunctionsTest.cpp
View File

@@ -187,7 +187,7 @@ PacketNum QuicLossFunctionsTest::sendPacket(
packet.packet, time, encodedSize, isHandshake, encodedSize);
outstandingPacket.associatedEvent = associatedEvent;
if (isHandshake) {
conn.outstandingHandshakePacketsCount++;
conn.outstandings.handshakePacketsCount++;
conn.lossState.lastHandshakePacketSentTime = time;
}
conn.lossState.lastRetransmittablePacketSentTime = time;
@@ -195,24 +195,24 @@ PacketNum QuicLossFunctionsTest::sendPacket(
conn.congestionController->onPacketSent(outstandingPacket);
}
if (associatedEvent) {
conn.outstandingClonedPacketsCount++;
conn.outstandings.clonedPacketsCount++;
// Simulates what the real writer does.
auto it = std::find_if(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
[&associatedEvent](const auto& packet) {
auto packetNum = packet.packet.header.getPacketSequenceNum();
return packetNum == *associatedEvent;
});
if (it != conn.outstandingPackets.end()) {
if (it != conn.outstandings.packets.end()) {
if (!it->associatedEvent) {
conn.outstandingPacketEvents.emplace(*associatedEvent);
conn.outstandingClonedPacketsCount++;
conn.outstandings.packetEvents.emplace(*associatedEvent);
conn.outstandings.clonedPacketsCount++;
it->associatedEvent = *associatedEvent;
}
}
}
conn.outstandingPackets.emplace_back(std::move(outstandingPacket));
conn.outstandings.packets.emplace_back(std::move(outstandingPacket));
conn.lossState.largestSent = getNextPacketNum(conn, packetNumberSpace);
increaseNextPacketNum(conn, packetNumberSpace);
conn.pendingEvents.setLossDetectionAlarm = true;
@@ -275,8 +275,8 @@ TEST_F(QuicLossFunctionsTest, TestOnLossDetectionAlarm) {
onLossDetectionAlarm<decltype(testingLossMarkFunc(lostPacket)), MockClock>(
*conn, testingLossMarkFunc(lostPacket));
EXPECT_EQ(conn->lossState.ptoCount, 2);
// PTO doesn't take anything out of outstandingPackets
EXPECT_FALSE(conn->outstandingPackets.empty());
// PTO doesn't take anything out of outstandings.packets
EXPECT_FALSE(conn->outstandings.packets.empty());
EXPECT_TRUE(conn->pendingEvents.setLossDetectionAlarm);
// PTO shouldn't mark loss
EXPECT_TRUE(lostPacket.empty());
@@ -290,16 +290,16 @@ TEST_F(QuicLossFunctionsTest, TestOnPTOSkipProcessed) {
EXPECT_CALL(*rawCongestionController, onPacketSent(_))
.WillRepeatedly(Return());
// By adding an associatedEvent that doesn't exist in the
// outstandingPacketEvents, they are all processed and will skip lossVisitor
// outstandings.packetEvents, they are all processed and will skip lossVisitor
for (auto i = 0; i < 10; i++) {
sendPacket(*conn, TimePoint(), i, PacketType::OneRtt);
}
EXPECT_EQ(10, conn->outstandingPackets.size());
EXPECT_EQ(10, conn->outstandings.packets.size());
std::vector<PacketNum> lostPackets;
EXPECT_CALL(*rawCongestionController, onRemoveBytesFromInflight(_)).Times(0);
EXPECT_CALL(*transportInfoCb_, onPTO());
onPTOAlarm(*conn);
EXPECT_EQ(10, conn->outstandingPackets.size());
EXPECT_EQ(10, conn->outstandings.packets.size());
EXPECT_TRUE(lostPackets.empty());
}
@@ -335,7 +335,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLoss) {
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto& packet =
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
auto packetNum = packet.header.getPacketSequenceNum();
@@ -371,7 +371,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossMerge) {
*headerCipher,
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto buf2 = buildRandomInputData(20);
writeDataToQuicStream(*stream1, buf2->clone(), false);
@@ -384,7 +384,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossMerge) {
*headerCipher,
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(2, conn->outstandings.packets.size());
auto& packet1 =
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
@@ -427,7 +427,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossNoMerge) {
*headerCipher,
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto buf2 = buildRandomInputData(20);
writeDataToQuicStream(*stream1, buf2->clone(), false);
@@ -440,7 +440,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossNoMerge) {
*headerCipher,
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(2, conn->outstandings.packets.size());
auto buf3 = buildRandomInputData(20);
writeDataToQuicStream(*stream1, buf3->clone(), false);
@@ -453,7 +453,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossNoMerge) {
*headerCipher,
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(3, conn->outstandingPackets.size());
EXPECT_EQ(3, conn->outstandings.packets.size());
auto& packet1 =
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
@@ -508,8 +508,8 @@ TEST_F(QuicLossFunctionsTest, RetxBufferSortedAfterLoss) {
*stream,
*buf3);
EXPECT_EQ(3, stream->retransmissionBuffer.size());
EXPECT_EQ(3, conn->outstandingPackets.size());
auto packet = conn->outstandingPackets[folly::Random::rand32() % 3];
EXPECT_EQ(3, conn->outstandings.packets.size());
auto packet = conn->outstandings.packets[folly::Random::rand32() % 3];
markPacketLoss(
*conn, packet.packet, false, packet.packet.header.getPacketSequenceNum());
EXPECT_EQ(2, stream->retransmissionBuffer.size());
@@ -539,9 +539,9 @@ TEST_F(QuicLossFunctionsTest, TestMarkCryptoLostAfterCancelRetransmission) {
*headerCipher,
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
ASSERT_EQ(conn->outstandingPackets.size(), 1);
ASSERT_EQ(conn->outstandings.packets.size(), 1);
EXPECT_GT(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0);
auto& packet = conn->outstandingPackets.front().packet;
auto& packet = conn->outstandings.packets.front().packet;
auto packetNum = packet.header.getPacketSequenceNum();
cancelHandshakeCryptoStreamRetransmissions(*conn->cryptoState);
markPacketLoss(*conn, packet, false, packetNum);
@@ -573,9 +573,9 @@ TEST_F(QuicLossFunctionsTest, TestMarkCryptoLostCancel) {
*headerCipher,
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
ASSERT_EQ(conn->outstandingPackets.size(), 1);
ASSERT_EQ(conn->outstandings.packets.size(), 1);
EXPECT_GT(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0);
auto& packet = conn->outstandingPackets.front().packet;
auto& packet = conn->outstandings.packets.front().packet;
auto packetNum = packet.header.getPacketSequenceNum();
markPacketLoss(*conn, packet, false, packetNum);
EXPECT_EQ(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0);
@@ -627,7 +627,7 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {
for (int i = 0; i < 6; ++i) {
sendPacket(*conn, Clock::now(), folly::none, PacketType::Handshake);
}
EXPECT_EQ(6, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(6, conn->outstandings.handshakePacketsCount);
// Assume some packets are already acked
for (auto iter =
getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake) + 2;
@@ -635,12 +635,12 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {
getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake) + 5;
iter++) {
if (iter->isHandshake) {
conn->outstandingHandshakePacketsCount--;
conn->outstandings.handshakePacketsCount--;
}
}
auto firstHandshakeOpIter =
getFirstOutstandingPacket(*conn, PacketNumberSpace::Handshake);
conn->outstandingPackets.erase(
conn->outstandings.packets.erase(
firstHandshakeOpIter + 2, firstHandshakeOpIter + 5);
// Ack for packet 9 arrives
auto lossEvent = detectLossPackets<decltype(testingLossMarkFunc)>(
@@ -657,12 +657,12 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {
EXPECT_EQ(lostPacket.back(), 2);
// Packet 6 is the only thing remaining inflight, it is a handshake pkt
EXPECT_EQ(1, conn->outstandingHandshakePacketsCount);
EXPECT_EQ(1, conn->outstandings.handshakePacketsCount);
// Packet 6 should remain in packet as the delta is less than threshold
EXPECT_EQ(conn->outstandingPackets.size(), 1);
EXPECT_EQ(conn->outstandings.packets.size(), 1);
auto packetNum =
conn->outstandingPackets.front().packet.header.getPacketSequenceNum();
conn->outstandings.packets.front().packet.header.getPacketSequenceNum();
EXPECT_EQ(packetNum, 6);
}
@@ -681,7 +681,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {
conn->version.value());
RegularQuicWritePacket outstandingRegularPacket(std::move(longHeader));
auto now = Clock::now();
conn->outstandingPackets.emplace_back(
conn->outstandings.packets.emplace_back(
OutstandingPacket(outstandingRegularPacket, now, 0, false, 0));
bool testLossMarkFuncCalled = false;
@@ -697,7 +697,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {
*conn, testLossMarkFunc, ackEvent, PacketNumberSpace::Handshake);
EXPECT_EQ(0, conn->lossState.ptoCount);
EXPECT_TRUE(conn->outstandingPackets.empty());
EXPECT_TRUE(conn->outstandings.packets.empty());
EXPECT_FALSE(conn->pendingEvents.setLossDetectionAlarm);
EXPECT_TRUE(testLossMarkFuncCalled);
}
@@ -736,10 +736,10 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckedPacket) {
EXPECT_EQ(0, conn->lossState.ptoCount);
EXPECT_EQ(0, conn->lossState.handshakeAlarmCount);
EXPECT_TRUE(conn->outstandingPackets.empty());
EXPECT_TRUE(conn->outstandings.packets.empty());
EXPECT_FALSE(conn->pendingEvents.setLossDetectionAlarm);
EXPECT_FALSE(testLossMarkFuncCalled);
ASSERT_TRUE(conn->outstandingPackets.empty());
ASSERT_TRUE(conn->outstandings.packets.empty());
setLossDetectionAlarm<decltype(timeout), MockClock>(*conn, timeout);
EXPECT_FALSE(conn->pendingEvents.setLossDetectionAlarm);
@@ -765,7 +765,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkRstLoss) {
*conn->version,
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_EQ(conn->outstandingPackets.size(), 1);
EXPECT_EQ(conn->outstandings.packets.size(), 1);
EXPECT_TRUE(conn->pendingEvents.resets.empty());
auto& packet =
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
@@ -857,7 +857,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkWindowUpdateLoss) {
conn->transportSettings.writeConnectionDataPacketsLimit);
EXPECT_FALSE(conn->streamManager->hasWindowUpdates());
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto& packet =
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet;
@@ -883,7 +883,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeReordering) {
// Some packets are already acked
conn->lossState.srtt = 400ms;
conn->lossState.lrtt = 350ms;
conn->outstandingPackets.erase(
conn->outstandings.packets.erase(
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData) + 2,
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData) + 5);
auto lossEvent = detectLossPackets<decltype(testingLossMarkFunc(lostPacket))>(
@@ -900,7 +900,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeReordering) {
EXPECT_EQ(lostPacket.back(), 2);
// Packet 6, 7 should remain in outstanding packet list
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(2, conn->outstandings.packets.size());
auto packetNum = getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
->packet.header.getPacketSequenceNum();
EXPECT_EQ(packetNum, 6);
@@ -945,14 +945,14 @@ TEST_F(QuicLossFunctionsTest, LossTimePreemptsCryptoTimer) {
// Second packet gets acked:
getAckState(*conn, PacketNumberSpace::Handshake).largestAckedByPeer = second;
conn->outstandingPackets.pop_back();
conn->outstandings.packets.pop_back();
MockClock::mockNow = [=]() { return sendTime + expectedDelayUntilLost + 5s; };
onLossDetectionAlarm<decltype(testingLossMarkFunc(lostPackets)), MockClock>(
*conn, testingLossMarkFunc(lostPackets));
EXPECT_EQ(1, lostPackets.size());
EXPECT_FALSE(
conn->lossState.lossTimes[PacketNumberSpace::Handshake].has_value());
EXPECT_TRUE(conn->outstandingPackets.empty());
EXPECT_TRUE(conn->outstandings.packets.empty());
}
TEST_F(QuicLossFunctionsTest, PTONoLongerMarksPacketsToBeRetransmitted) {
@@ -1006,8 +1006,8 @@ TEST_F(
expectedLargestLostNum, i % 2 ? sentPacketNum : expectedLargestLostNum);
}
uint64_t expectedLostBytes = std::accumulate(
conn->outstandingPackets.begin(),
conn->outstandingPackets.end(),
conn->outstandings.packets.begin(),
conn->outstandings.packets.end(),
0,
[](uint64_t num, const OutstandingPacket& packet) {
return packet.isHandshake ? num + packet.encodedSize : num;
@@ -1214,9 +1214,9 @@ TEST_F(QuicLossFunctionsTest, NoDoubleProcess) {
for (size_t i = 0; i < 6; i++) {
lastSent = sendPacket(*conn, Clock::now(), event, PacketType::OneRtt);
}
EXPECT_EQ(6, conn->outstandingPackets.size());
// Add the PacketEvent to the outstandingPacketEvents set
conn->outstandingPacketEvents.insert(event);
EXPECT_EQ(6, conn->outstandings.packets.size());
// Add the PacketEvent to the outstandings.packetEvents set
conn->outstandings.packetEvents.insert(event);
// Ack the last sent packet. Despite two losses, lossVisitor only visit one
// packet
@@ -1227,7 +1227,7 @@ TEST_F(QuicLossFunctionsTest, NoDoubleProcess) {
TimePoint(100ms),
PacketNumberSpace::AppData);
EXPECT_EQ(1, lossVisitorCount);
EXPECT_EQ(4, conn->outstandingPackets.size());
EXPECT_EQ(4, conn->outstandings.packets.size());
}
TEST_F(QuicLossFunctionsTest, DetectPacketLossClonedPacketsCounter) {
@@ -1246,14 +1246,14 @@ TEST_F(QuicLossFunctionsTest, DetectPacketLossClonedPacketsCounter) {
noopLossMarker,
Clock::now(),
PacketNumberSpace::AppData);
EXPECT_EQ(0, conn->outstandingClonedPacketsCount);
EXPECT_EQ(0, conn->outstandings.clonedPacketsCount);
}
TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) {
MockAsyncUDPSocket socket(&evb);
auto conn = createConn();
ASSERT_TRUE(conn->outstandingPackets.empty());
ASSERT_TRUE(conn->outstandingPacketEvents.empty());
ASSERT_TRUE(conn->outstandings.packets.empty());
ASSERT_TRUE(conn->outstandings.packetEvents.empty());
auto stream1Id =
conn->streamManager->createNextBidirectionalStream().value()->id;
auto buf = folly::IOBuf::copyBuffer("I wrestled by the sea.");
@@ -1276,8 +1276,8 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) {
true);
EXPECT_FALSE(conn->streamManager->pendingWindowUpdate(stream2->id));
EXPECT_FALSE(conn->pendingEvents.connWindowUpdate);
ASSERT_EQ(1, conn->outstandingPackets.size());
ASSERT_TRUE(conn->outstandingPacketEvents.empty());
ASSERT_EQ(1, conn->outstandings.packets.size());
ASSERT_TRUE(conn->outstandings.packetEvents.empty());
uint32_t streamDataCounter = 0, streamWindowUpdateCounter = 0,
connWindowUpdateCounter = 0;
for (const auto& frame :
@@ -1358,7 +1358,7 @@ TEST_F(QuicLossFunctionsTest, TotalLossCount) {
largestSent =
sendPacket(*conn, Clock::now(), folly::none, PacketType::OneRtt);
}
EXPECT_EQ(10, conn->outstandingPackets.size());
EXPECT_EQ(10, conn->outstandings.packets.size());
uint32_t lostPackets = 0;
auto countingLossVisitor = [&](auto& /* conn */,
auto& /* packet */,
@@ -1387,13 +1387,13 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejected) {
EXPECT_CALL(*rawCongestionController, onPacketSent(_))
.WillRepeatedly(Return());
// By adding an associatedEvent that doesn't exist in the
// outstandingPacketEvents, they are all processed and will skip lossVisitor
// outstandings.packetEvents, they are all processed and will skip lossVisitor
for (auto i = 0; i < 2; i++) {
sendPacket(*conn, TimePoint(), folly::none, PacketType::OneRtt);
sendPacket(*conn, TimePoint(), folly::none, PacketType::ZeroRtt);
}
EXPECT_FALSE(conn->outstandingPackets.empty());
EXPECT_EQ(4, conn->outstandingPackets.size());
EXPECT_FALSE(conn->outstandings.packets.empty());
EXPECT_EQ(4, conn->outstandings.packets.size());
std::vector<std::pair<PacketNum, bool>> lostPackets;
// onRemoveBytesFromInflight should still happen
EXPECT_CALL(*rawCongestionController, onRemoveBytesFromInflight(_)).Times(1);
@@ -1401,13 +1401,13 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejected) {
*conn, [&lostPackets](auto&, auto&, bool processed, PacketNum packetNum) {
lostPackets.emplace_back(packetNum, processed);
});
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(2, conn->outstandings.packets.size());
EXPECT_EQ(lostPackets.size(), 2);
for (auto lostPacket : lostPackets) {
EXPECT_FALSE(lostPacket.second);
}
for (size_t i = 0; i < conn->outstandingPackets.size(); ++i) {
auto longHeader = conn->outstandingPackets[i].packet.header.asLong();
for (size_t i = 0; i < conn->outstandings.packets.size(); ++i) {
auto longHeader = conn->outstandings.packets[i].packet.header.asLong();
EXPECT_FALSE(
longHeader &&
longHeader->getProtectionType() == ProtectionType::ZeroRtt);
@@ -1423,7 +1423,7 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejectedWithClones) {
EXPECT_CALL(*rawCongestionController, onPacketSent(_))
.WillRepeatedly(Return());
// By adding an associatedEvent that doesn't exist in the
// outstandingPacketEvents, they are all processed and will skip lossVisitor
// outstandings.packetEvents, they are all processed and will skip lossVisitor
std::set<PacketNum> zeroRttPackets;
folly::Optional<PacketNum> lastPacket;
for (auto i = 0; i < 2; i++) {
@@ -1438,9 +1438,9 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejectedWithClones) {
sendPacket(*conn, TimePoint(), zeroRttPacketNum, PacketType::OneRtt);
}
EXPECT_EQ(6, conn->outstandingPackets.size());
ASSERT_EQ(conn->outstandingClonedPacketsCount, 6);
ASSERT_EQ(conn->outstandingPacketEvents.size(), 2);
EXPECT_EQ(6, conn->outstandings.packets.size());
ASSERT_EQ(conn->outstandings.clonedPacketsCount, 6);
ASSERT_EQ(conn->outstandings.packetEvents.size(), 2);
std::vector<std::pair<PacketNum, bool>> lostPackets;
// onRemoveBytesFromInflight should still happen
@@ -1449,17 +1449,17 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejectedWithClones) {
*conn, [&lostPackets](auto&, auto&, bool processed, PacketNum packetNum) {
lostPackets.emplace_back(packetNum, processed);
});
ASSERT_EQ(conn->outstandingPacketEvents.size(), 0);
EXPECT_EQ(3, conn->outstandingPackets.size());
ASSERT_EQ(conn->outstandings.packetEvents.size(), 0);
EXPECT_EQ(3, conn->outstandings.packets.size());
EXPECT_EQ(lostPackets.size(), 3);
ASSERT_EQ(conn->outstandingClonedPacketsCount, 3);
ASSERT_EQ(conn->outstandings.clonedPacketsCount, 3);
size_t numProcessed = 0;
for (auto lostPacket : lostPackets) {
numProcessed += lostPacket.second;
}
EXPECT_EQ(numProcessed, 1);
for (size_t i = 0; i < conn->outstandingPackets.size(); ++i) {
auto longHeader = conn->outstandingPackets[i].packet.header.asLong();
for (size_t i = 0; i < conn->outstandings.packets.size(); ++i) {
auto longHeader = conn->outstandings.packets[i].packet.header.asLong();
EXPECT_FALSE(
longHeader &&
longHeader->getProtectionType() == ProtectionType::ZeroRtt);
@@ -1509,12 +1509,12 @@ TEST_P(QuicLossFunctionsTest, CappedShiftNoCrash) {
conn->lossState.handshakeAlarmCount =
std::numeric_limits<decltype(conn->lossState.handshakeAlarmCount)>::max();
sendPacket(*conn, Clock::now(), folly::none, PacketType::Handshake);
ASSERT_GT(conn->outstandingHandshakePacketsCount, 0);
ASSERT_GT(conn->outstandings.handshakePacketsCount, 0);
calculateAlarmDuration(*conn);
conn->lossState.handshakeAlarmCount = 0;
conn->outstandingHandshakePacketsCount = 0;
conn->outstandingPackets.clear();
conn->outstandings.handshakePacketsCount = 0;
conn->outstandings.packets.clear();
conn->lossState.ptoCount =
std::numeric_limits<decltype(conn->lossState.ptoCount)>::max();
sendPacket(*conn, Clock::now(), folly::none, PacketType::OneRtt);

37
quic/server/test/QuicServerTransportTest.cpp
View File

@@ -506,7 +506,7 @@ class QuicServerTransportTest : public Test {
// Issue (kMinNumAvailableConnIds - 1) more connection ids on handshake
// complete
auto numNewConnIdFrames = 0;
for (const auto& packet : server->getConn().outstandingPackets) {
for (const auto& packet : server->getConn().outstandings.packets) {
for (const auto& frame : packet.packet.frames) {
switch (frame.type()) {
case QuicWriteFrame::Type::QuicSimpleFrame_E: {
@@ -813,9 +813,9 @@ TEST_F(QuicServerTransportTest, IdleTimerNotResetOnDuplicatePacket) {
TEST_F(QuicServerTransportTest, IdleTimerNotResetWhenDataOutstanding) {
// Clear the receivedNewPacketBeforeWrite flag, since we may reveice from
// client during the SetUp of the test case.
server->getNonConstConn().outstandingPackets.clear();
server->getNonConstConn().outstandings.packets.clear();
server->getNonConstConn().receivedNewPacketBeforeWrite = false;
server->getNonConstConn().outstandingPackets.clear();
server->getNonConstConn().outstandings.packets.clear();
StreamId streamId = server->createBidirectionalStream().value();
server->idleTimeout().cancelTimeout();
@@ -1175,8 +1175,8 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
auto data = IOBuf::copyBuffer("Aloha");
// Remove any packets that might have been queued.
server->getNonConstConn().outstandingPackets.clear();
server->getNonConstConn().outstandingHandshakePacketsCount = 0;
server->getNonConstConn().outstandings.packets.clear();
server->getNonConstConn().outstandings.handshakePacketsCount = 0;
server->writeChain(streamId, data->clone(), false, false);
loopForWrites();
server->writeChain(streamId, data->clone(), false, false);
@@ -1184,10 +1184,10 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
loopForWrites();
auto stream = server->getNonConstConn().streamManager->getStream(streamId);
ASSERT_FALSE(server->getConn().outstandingPackets.empty());
ASSERT_FALSE(server->getConn().outstandings.packets.empty());
ASSERT_FALSE(stream->retransmissionBuffer.empty());
// We need more than one packet for this test.
ASSERT_FALSE(server->getConn().outstandingPackets.empty());
ASSERT_FALSE(server->getConn().outstandings.packets.empty());
PacketNum packetNum1 =
getFirstOutstandingPacket(
@@ -1200,9 +1200,9 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
->packet.header.getPacketSequenceNum();
uint32_t buffersInPacket1 = 0;
for (size_t i = 0; i < server->getNonConstConn().outstandingPackets.size();
for (size_t i = 0; i < server->getNonConstConn().outstandings.packets.size();
++i) {
auto& packet = server->getNonConstConn().outstandingPackets[i];
auto& packet = server->getNonConstConn().outstandings.packets[i];
if (packet.packet.header.getPacketNumberSpace() !=
PacketNumberSpace::AppData) {
continue;
@@ -1265,7 +1265,7 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
auto empty = IOBuf::create(0);
server->writeChain(streamId, std::move(empty), true, false);
loopForWrites();
ASSERT_FALSE(server->getConn().outstandingPackets.empty());
ASSERT_FALSE(server->getConn().outstandings.packets.empty());
PacketNum finPacketNum =
getFirstOutstandingPacket(
@@ -1778,8 +1778,8 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) {
server->getNonConstConn().qLogger = qLogger;
server->getNonConstConn().streamManager->getStream(streamId);
// knock every handshake outstanding packets out
server->getNonConstConn().outstandingHandshakePacketsCount = 0;
server->getNonConstConn().outstandingPackets.clear();
server->getNonConstConn().outstandings.handshakePacketsCount = 0;
server->getNonConstConn().outstandings.packets.clear();
for (auto& t : server->getNonConstConn().lossState.lossTimes) {
t.reset();
}
@@ -1788,17 +1788,18 @@ TEST_F(QuicServerTransportTest, TestCloneStopSending) {
loopForWrites();
// Find the outstanding StopSending.
auto packetItr = std::find_if(
server->getNonConstConn().outstandingPackets.begin(),
server->getNonConstConn().outstandingPackets.end(),
server->getNonConstConn().outstandings.packets.begin(),
server->getNonConstConn().outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::StopSendingFrame_E>());
ASSERT_TRUE(packetItr != server->getNonConstConn().outstandingPackets.end());
ASSERT_TRUE(
packetItr != server->getNonConstConn().outstandings.packets.end());
// Force a timeout with no data so that it clones the packet
server->lossTimeout().timeoutExpired();
loopForWrites();
auto numStopSendingPackets = std::count_if(
server->getNonConstConn().outstandingPackets.begin(),
server->getNonConstConn().outstandingPackets.end(),
server->getNonConstConn().outstandings.packets.begin(),
server->getNonConstConn().outstandings.packets.end(),
findFrameInPacketFunc<QuicSimpleFrame::Type::StopSendingFrame_E>());
EXPECT_GT(numStopSendingPackets, 1);
@@ -3696,7 +3697,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestSendHandshakeDone) {
setupClientReadCodec();
recvClientHello(true, QuicVersion::QUIC_DRAFT);
recvClientFinished(true, nullptr, QuicVersion::QUIC_DRAFT);
auto& packets = server->getConn().outstandingPackets;
auto& packets = server->getConn().outstandings.packets;
ASSERT_FALSE(packets.empty());
int numHandshakeDone = 0;
for (auto& p : packets) {

41
quic/state/AckHandlers.cpp
View File

@@ -23,7 +23,7 @@ namespace quic {
* order of packet number. For each ack block, we try to find a continuous range
* of outstanding packets in the connection's outstanding packets list that is
* acked by the current ack block. The search is in the reverse order of the
* outstandingPackets given that the list is sorted in the ascending order of
* outstandings.packets given that the list is sorted in the ascending order of
* packet number. For each outstanding packet that is acked by current ack
* frame, ack and loss visitors are invoked on the sent frames. The outstanding
* packets may contain packets from all three packet number spaces. But ack is
@@ -54,22 +54,22 @@ void processAckFrame(
lastAckedPacketSentTime;
auto ackBlockIt = frame.ackBlocks.cbegin();
while (ackBlockIt != frame.ackBlocks.cend() &&
currentPacketIt != conn.outstandingPackets.rend()) {
currentPacketIt != conn.outstandings.packets.rend()) {
// In reverse order, find the first outstanding packet that has a packet
// number LE the endPacket of the current ack range.
auto rPacketIt = std::lower_bound(
currentPacketIt,
conn.outstandingPackets.rend(),
conn.outstandings.packets.rend(),
ackBlockIt->endPacket,
[&](const auto& packetWithTime, const auto& val) {
return packetWithTime.packet.header.getPacketSequenceNum() > val;
});
if (rPacketIt == conn.outstandingPackets.rend()) {
if (rPacketIt == conn.outstandings.packets.rend()) {
// This means that all the packets are greater than the end packet.
// Since we iterate the ACK blocks in reverse order of end packets, our
// work here is done.
VLOG(10) << __func__ << " less than all outstanding packets outstanding="
<< conn.outstandingPackets.size() << " range=["
<< conn.outstandings.packets.size() << " range=["
<< ackBlockIt->startPacket << ", " << ackBlockIt->endPacket
<< "]"
<< " " << conn;
@@ -80,7 +80,7 @@ void processAckFrame(
// TODO: only process ACKs from packets which are sent from a greater than
// or equal to crypto protection level.
auto eraseEnd = rPacketIt;
while (rPacketIt != conn.outstandingPackets.rend()) {
while (rPacketIt != conn.outstandings.packets.rend()) {
auto currentPacketNum = rPacketIt->packet.header.getPacketSequenceNum();
auto currentPacketNumberSpace =
rPacketIt->packet.header.getPacketNumberSpace();
@@ -91,8 +91,8 @@ void processAckFrame(
// this ack block. So the code erases the current iterator range and
// move the iterator to be the next search point.
if (rPacketIt != eraseEnd) {
auto nextElem =
conn.outstandingPackets.erase(rPacketIt.base(), eraseEnd.base());
auto nextElem = conn.outstandings.packets.erase(
rPacketIt.base(), eraseEnd.base());
rPacketIt = std::reverse_iterator<decltype(nextElem)>(nextElem) + 1;
eraseEnd = rPacketIt;
} else {
@@ -123,15 +123,15 @@ void processAckFrame(
updateRtt(conn, rttSample, frame.ackDelay);
}
// Only invoke AckVisitor if the packet doesn't have an associated
// PacketEvent; or the PacketEvent is in conn.outstandingPacketEvents
// PacketEvent; or the PacketEvent is in conn.outstandings.packetEvents
if (!rPacketIt->associatedEvent ||
conn.outstandingPacketEvents.count(*rPacketIt->associatedEvent)) {
conn.outstandings.packetEvents.count(*rPacketIt->associatedEvent)) {
for (auto& packetFrame : rPacketIt->packet.frames) {
ackVisitor(*rPacketIt, packetFrame, frame);
}
// Remove this PacketEvent from the outstandingPacketEvents set
// Remove this PacketEvent from the outstandings.packetEvents set
if (rPacketIt->associatedEvent) {
conn.outstandingPacketEvents.erase(*rPacketIt->associatedEvent);
conn.outstandings.packetEvents.erase(*rPacketIt->associatedEvent);
}
}
if (!ack.largestAckedPacket ||
@@ -167,7 +167,7 @@ void processAckFrame(
// the next search point.
if (rPacketIt != eraseEnd) {
auto nextElem =
conn.outstandingPackets.erase(rPacketIt.base(), eraseEnd.base());
conn.outstandings.packets.erase(rPacketIt.base(), eraseEnd.base());
currentPacketIt = std::reverse_iterator<decltype(nextElem)>(nextElem);
} else {
currentPacketIt = rPacketIt;
@@ -177,14 +177,15 @@ void processAckFrame(
if (lastAckedPacketSentTime) {
conn.lossState.lastAckedPacketSentTime = *lastAckedPacketSentTime;
}
DCHECK_GE(conn.outstandingHandshakePacketsCount, handshakePacketAcked);
conn.outstandingHandshakePacketsCount -= handshakePacketAcked;
DCHECK_GE(conn.outstandingClonedPacketsCount, clonedPacketsAcked);
conn.outstandingClonedPacketsCount -= clonedPacketsAcked;
auto updatedOustandingPacketsCount = conn.outstandingPackets.size();
DCHECK_GE(conn.outstandings.handshakePacketsCount, handshakePacketAcked);
conn.outstandings.handshakePacketsCount -= handshakePacketAcked;
DCHECK_GE(conn.outstandings.clonedPacketsCount, clonedPacketsAcked);
conn.outstandings.clonedPacketsCount -= clonedPacketsAcked;
auto updatedOustandingPacketsCount = conn.outstandings.packets.size();
DCHECK_GE(
updatedOustandingPacketsCount, conn.outstandingHandshakePacketsCount);
DCHECK_GE(updatedOustandingPacketsCount, conn.outstandingClonedPacketsCount);
updatedOustandingPacketsCount, conn.outstandings.handshakePacketsCount);
DCHECK_GE(
updatedOustandingPacketsCount, conn.outstandings.clonedPacketsCount);
auto lossEvent = handleAckForLoss(conn, lossVisitor, ack, pnSpace);
if (conn.congestionController &&
(ack.largestAckedPacket.has_value() || lossEvent)) {

2
quic/state/QuicPacingFunctions.cpp
View File

@@ -18,4 +18,4 @@ void updatePacingOnClose(QuicConnectionStateBase& conn) {
conn.canBePaced = false;
}
}
} // namespace quic

2
quic/state/QuicPacingFunctions.h
View File

@@ -16,4 +16,4 @@ void updatePacingOnKeyEstablished(QuicConnectionStateBase& conn);
void updatePacingOnClose(QuicConnectionStateBase& conn);
}
} // namespace quic

9
quic/state/QuicStateFunctions.cpp
View File

@@ -19,7 +19,7 @@ getPreviousOutstandingPacket(
quic::PacketNumberSpace packetNumberSpace,
std::deque<quic::OutstandingPacket>::reverse_iterator from) {
return std::find_if(
from, conn.outstandingPackets.rend(), [=](const auto& op) {
from, conn.outstandings.packets.rend(), [=](const auto& op) {
return packetNumberSpace == op.packet.header.getPacketNumberSpace();
});
}
@@ -212,21 +212,22 @@ std::deque<OutstandingPacket>::iterator getFirstOutstandingPacket(
QuicConnectionStateBase& conn,
PacketNumberSpace packetNumberSpace) {
return getNextOutstandingPacket(
conn, packetNumberSpace, conn.outstandingPackets.begin());
conn, packetNumberSpace, conn.outstandings.packets.begin());
}
std::deque<OutstandingPacket>::reverse_iterator getLastOutstandingPacket(
QuicConnectionStateBase& conn,
PacketNumberSpace packetNumberSpace) {
return getPreviousOutstandingPacket(
conn, packetNumberSpace, conn.outstandingPackets.rbegin());
conn, packetNumberSpace, conn.outstandings.packets.rbegin());
}
std::deque<OutstandingPacket>::iterator getNextOutstandingPacket(
QuicConnectionStateBase& conn,
PacketNumberSpace packetNumberSpace,
std::deque<OutstandingPacket>::iterator from) {
return std::find_if(from, conn.outstandingPackets.end(), [=](const auto& op) {
return std::find_if(
from, conn.outstandings.packets.end(), [=](const auto& op) {
return packetNumberSpace == op.packet.header.getPacketNumberSpace();
});
}

42
quic/state/StateData.h
View File

@@ -179,6 +179,23 @@ struct OutstandingPacket {
totalBytesSent(totalBytesSentIn) {}
};
struct OutstandingsInfo {
// Sent packets which have not been acked. These are sorted by PacketNum.
std::deque<OutstandingPacket> packets;
// All PacketEvents of this connection. If a OutstandingPacket doesn't have an
// associatedEvent or if it's not in this set, there is no need to process its
// frames upon ack or loss.
// TODO: Enforce only AppTraffic packets to be clonable
folly::F14FastSet<PacketEvent> packetEvents;
// Number of handshake packets outstanding.
uint64_t handshakePacketsCount{0};
// Number of packets are clones or cloned.
uint64_t clonedPacketsCount{0};
};
struct Pacer {
virtual ~Pacer() = default;
@@ -352,9 +369,9 @@ struct CongestionController {
* Take bytes out of flight without mutating other states of the controller
* TODO(yangchi): I'm not sure how long I'd like to keep this API. This is a
* temporary workaround the fact that there are packets we will need to take
* out of outstandingPackets but not considered loss for congestion control
* perspective. In long term, we shouldn't take them out of
* outstandingPackets, then we don't have to do this.
* out of outstandings.packets but not considered loss for congestion
* control perspective. In long term, we shouldn't take them out of
* outstandings.packets, then we don't have to do this.
*/
virtual void onRemoveBytesFromInflight(uint64_t) = 0;
virtual void onPacketSent(const OutstandingPacket& packet) = 0;
@@ -535,22 +552,9 @@ struct QuicConnectionStateBase : public folly::DelayedDestruction {
std::unique_ptr<PendingPathRateLimiter> pathValidationLimiter;
// TODO: We really really should wrap outstandingPackets, all its associated
// counters and the outstandingPacketEvents into one class.
// Sent packets which have not been acked. These are sorted by PacketNum.
std::deque<OutstandingPacket> outstandingPackets;
// All PacketEvents of this connection. If a OutstandingPacket doesn't have an
// associatedEvent or if it's not in this set, there is no need to process its
// frames upon ack or loss.
// TODO: Enforce only AppTraffic packets to be clonable
folly::F14FastSet<PacketEvent> outstandingPacketEvents;
// Number of handshake packets outstanding.
uint64_t outstandingHandshakePacketsCount{0};
// Number of packets are clones or cloned.
uint64_t outstandingClonedPacketsCount{0};
// Outstanding packets, packet events, and associated counters wrapped in one
// class
OutstandingsInfo outstandings;
// The read codec to decrypt and decode packets.
std::unique_ptr<QuicReadCodec> readCodec;

2
quic/state/stream/StreamStateFunctions.h
View File

@@ -19,4 +19,4 @@ void resetQuicStream(QuicStreamState& stream, ApplicationErrorCode error);
void onResetQuicStream(QuicStreamState& stream, RstStreamFrame&& frame);
bool isAllDataReceived(const QuicStreamState& stream);
}
} // namespace quic

26
quic/state/stream/test/StreamStateMachineTest.cpp
View File

@@ -161,7 +161,7 @@ TEST_F(QuicOpenStateTest, AckStream) {
true);
EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto& streamFrame =
*getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -211,10 +211,10 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) {
false);
EXPECT_EQ(stream->retransmissionBuffer.size(), 3);
EXPECT_EQ(3, conn->outstandingPackets.size());
EXPECT_EQ(3, conn->outstandings.packets.size());
auto& streamFrame3 =
*conn->outstandingPackets[2].packet.frames[0].asWriteStreamFrame();
*conn->outstandings.packets[2].packet.frames[0].asWriteStreamFrame();
sendAckSMHandler(*stream, streamFrame3);
ASSERT_EQ(stream->sendState, StreamSendState::Open_E);
@@ -222,7 +222,7 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) {
ASSERT_EQ(stream->ackedIntervals.front().end, 21);
auto& streamFrame2 =
*conn->outstandingPackets[1].packet.frames[0].asWriteStreamFrame();
*conn->outstandings.packets[1].packet.frames[0].asWriteStreamFrame();
sendAckSMHandler(*stream, streamFrame2);
ASSERT_EQ(stream->sendState, StreamSendState::Open_E);
@@ -230,7 +230,7 @@ TEST_F(QuicOpenStateTest, AckStreamMulti) {
ASSERT_EQ(stream->ackedIntervals.front().end, 21);
auto& streamFrame1 =
*conn->outstandingPackets[0].packet.frames[0].asWriteStreamFrame();
*conn->outstandings.packets[0].packet.frames[0].asWriteStreamFrame();
sendAckSMHandler(*stream, streamFrame1);
ASSERT_EQ(stream->sendState, StreamSendState::Open_E);
@@ -275,9 +275,9 @@ TEST_F(QuicOpenStateTest, RetxBufferSortedAfterAck) {
false);
EXPECT_EQ(3, stream->retransmissionBuffer.size());
EXPECT_EQ(3, conn->outstandingPackets.size());
auto packet = conn->outstandingPackets[folly::Random::rand32() % 3];
auto streamFrame = *conn->outstandingPackets[std::rand() % 3]
EXPECT_EQ(3, conn->outstandings.packets.size());
auto packet = conn->outstandings.packets[folly::Random::rand32() % 3];
auto streamFrame = *conn->outstandings.packets[std::rand() % 3]
.packet.frames.front()
.asWriteStreamFrame();
sendAckSMHandler(*stream, streamFrame);
@@ -305,7 +305,7 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkip) {
true);
EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto& streamFrame =
*getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -349,7 +349,7 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkipHalfBuf) {
true);
EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto& streamFrame =
*getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -400,7 +400,7 @@ TEST_F(QuicOpenStateTest, AckStreamAfterSkipOneAndAHalfBuf) {
true);
EXPECT_EQ(stream->retransmissionBuffer.size(), 2);
EXPECT_EQ(2, conn->outstandingPackets.size());
EXPECT_EQ(2, conn->outstandings.packets.size());
auto streamFrameIt =
getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData);
@@ -545,7 +545,7 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStream) {
true);
EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto& streamFrame =
*getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)
@@ -583,7 +583,7 @@ TEST_F(QuicHalfClosedRemoteStateTest, AckStreamAfterSkip) {
true);
EXPECT_EQ(stream->retransmissionBuffer.size(), 1);
EXPECT_EQ(1, conn->outstandingPackets.size());
EXPECT_EQ(1, conn->outstandings.packets.size());
auto& streamFrame =
*getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)

76
quic/state/test/AckHandlersTest.cpp
View File

@@ -50,7 +50,7 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocks) {
createNewPacket(packetNum, GetParam());
WriteStreamFrame frame(currentStreamId++, 0, 0, true);
regularPacket.frames.emplace_back(std::move(frame));
conn.outstandingPackets.emplace_back(OutstandingPacket(
conn.outstandings.packets.emplace_back(OutstandingPacket(
std::move(regularPacket), sentTime, 1, false, packetNum));
}
ReadAckFrame ackFrame;
@@ -94,13 +94,13 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocks) {
start--;
}
// only unacked packets should be remaining
EXPECT_EQ(conn.outstandingPackets.size(), 5);
EXPECT_EQ(conn.outstandings.packets.size(), 5);
PacketNum lostPackt = 10;
for (auto& pkt : lostPackets) {
EXPECT_EQ(pkt, lostPackt++);
}
PacketNum packetNum = 16;
for (auto& packet : conn.outstandingPackets) {
for (auto& packet : conn.outstandings.packets) {
auto currentPacketNum = packet.packet.header.getPacketSequenceNum();
EXPECT_EQ(currentPacketNum, packetNum);
packetNum++;
@@ -121,7 +121,7 @@ TEST_P(AckHandlersTest, TestAckBlocksWithGaps) {
auto regularPacket = createNewPacket(packetNum, GetParam());
WriteStreamFrame frame(currentStreamId++, 0, 0, true);
regularPacket.frames.emplace_back(std::move(frame));
conn.outstandingPackets.emplace_back(OutstandingPacket(
conn.outstandings.packets.emplace_back(OutstandingPacket(
std::move(regularPacket), Clock::now(), 1, false, packetNum));
}
@@ -185,8 +185,8 @@ TEST_P(AckHandlersTest, TestAckBlocksWithGaps) {
std::vector<PacketNum> actualPacketNumbers;
std::transform(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
std::back_insert_iterator<decltype(actualPacketNumbers)>(
actualPacketNumbers),
[](const auto& packet) {
@@ -222,7 +222,7 @@ TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
auto regularPacket = createNewPacket(packetNum, GetParam());
WriteStreamFrame frame(current++, 0, 0, true);
regularPacket.frames.emplace_back(std::move(frame));
conn.outstandingPackets.emplace_back(OutstandingPacket(
conn.outstandings.packets.emplace_back(OutstandingPacket(
std::move(regularPacket), Clock::now(), 1, false, packetNum));
}
@@ -231,7 +231,7 @@ TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
WriteStreamFrame frame(current, 0, 0, true);
current += 3;
regularPacket.frames.emplace_back(std::move(frame));
conn.outstandingPackets.emplace_back(OutstandingPacket(
conn.outstandings.packets.emplace_back(OutstandingPacket(
std::move(regularPacket), Clock::now(), 1, false, packetNum));
}
@@ -286,8 +286,8 @@ TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
std::vector<PacketNum> actualPacketNumbers;
std::transform(
conn.outstandingPackets.begin(),
conn.outstandingPackets.end(),
conn.outstandings.packets.begin(),
conn.outstandings.packets.end(),
std::back_insert_iterator<decltype(actualPacketNumbers)>(
actualPacketNumbers),
[](const auto& packet) {
@@ -311,7 +311,7 @@ TEST_P(AckHandlersTest, AckVisitorForAckTest) {
conn.ackStates.appDataAckState.acks.insert(900, 1000);
conn.ackStates.appDataAckState.acks.insert(500, 700);
firstPacket.frames.emplace_back(std::move(firstAckFrame));
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
OutstandingPacket(std::move(firstPacket), Clock::now(), 0, false, 0));
auto secondPacket = createNewPacket(101 /* packetNum */, GetParam());
@@ -321,7 +321,7 @@ TEST_P(AckHandlersTest, AckVisitorForAckTest) {
conn.ackStates.appDataAckState.acks.insert(1100, 2000);
conn.ackStates.appDataAckState.acks.insert(1002, 1090);
secondPacket.frames.emplace_back(std::move(secondAckFrame));
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
OutstandingPacket(std::move(secondPacket), Clock::now(), 0, false, 0));
ReadAckFrame firstReceivedAck;
@@ -385,7 +385,7 @@ TEST_P(AckHandlersTest, NoNewAckedPacket) {
conn.lossState.ptoCount = 1;
PacketNum packetAfterRtoNum = 10;
auto packetAfterRto = createNewPacket(packetAfterRtoNum, GetParam());
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
OutstandingPacket(std::move(packetAfterRto), Clock::now(), 0, false, 0));
ReadAckFrame ackFrame;
@@ -429,12 +429,12 @@ TEST_P(AckHandlersTest, AckPacketNumDoesNotExist) {
PacketNum packetNum1 = 9;
auto regularPacket1 = createNewPacket(packetNum1, GetParam());
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
std::move(regularPacket1), Clock::now(), 0, false, 0);
PacketNum packetNum2 = 10;
auto regularPacket2 = createNewPacket(packetNum2, GetParam());
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
std::move(regularPacket2), Clock::now(), 0, false, 0);
// Ack a packet one higher than the packet so that we don't trigger reordering
@@ -450,7 +450,7 @@ TEST_P(AckHandlersTest, AckPacketNumDoesNotExist) {
[](const auto&, const auto&, const auto&) {},
[](auto&, auto&, bool, PacketNum) {},
Clock::now());
EXPECT_EQ(1, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.packets.size());
}
TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
@@ -461,13 +461,13 @@ TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
WriteStreamFrame frame(
stream, 100 * packetNum + 0, 100 * packetNum + 100, false);
regularPacket.frames.emplace_back(std::move(frame));
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
std::move(regularPacket),
Clock::now(),
0,
packetNum % 2,
packetNum / 2);
conn.outstandingHandshakePacketsCount += packetNum % 2;
conn.outstandings.handshakePacketsCount += packetNum % 2;
}
ReadAckFrame ackFrame;
@@ -484,8 +484,8 @@ TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
Clock::now());
// When [3, 7] are acked, [0, 2] will also be marked loss, due to reordering
// threshold
EXPECT_EQ(1, conn.outstandingHandshakePacketsCount);
EXPECT_EQ(2, conn.outstandingPackets.size());
EXPECT_EQ(1, conn.outstandings.handshakePacketsCount);
EXPECT_EQ(2, conn.outstandings.packets.size());
}
TEST_P(AckHandlersTest, PurgeAcks) {
@@ -524,7 +524,7 @@ TEST_P(AckHandlersTest, NoSkipAckVisitor) {
// We need to at least have one frame to trigger ackVisitor
WriteStreamFrame frame(0, 0, 0, true);
regularPacket.frames.emplace_back(std::move(frame));
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
OutstandingPacket(std::move(regularPacket), Clock::now(), 1, false, 1));
ReadAckFrame ackFrame;
ackFrame.largestAcked = 0;
@@ -570,10 +570,10 @@ TEST_P(AckHandlersTest, SkipAckVisitor) {
OutstandingPacket outstandingPacket(
std::move(regularPacket), Clock::now(), 1, false, 1);
// Give this outstandingPacket an associatedEvent that's not in
// outstandingPacketEvents
// outstandings.packetEvents
outstandingPacket.associatedEvent = 0;
conn.outstandingPackets.push_back(std::move(outstandingPacket));
conn.outstandingClonedPacketsCount++;
conn.outstandings.packets.push_back(std::move(outstandingPacket));
conn.outstandings.clonedPacketsCount++;
ReadAckFrame ackFrame;
ackFrame.largestAcked = 0;
@@ -618,10 +618,10 @@ TEST_P(AckHandlersTest, NoDoubleProcess) {
// The seconds packet has the same PacketEvent
outstandingPacket2.associatedEvent = packetNum1;
conn.outstandingPackets.push_back(std::move(outstandingPacket1));
conn.outstandingPackets.push_back(std::move(outstandingPacket2));
conn.outstandingClonedPacketsCount += 2;
conn.outstandingPacketEvents.insert(packetNum1);
conn.outstandings.packets.push_back(std::move(outstandingPacket1));
conn.outstandings.packets.push_back(std::move(outstandingPacket2));
conn.outstandings.clonedPacketsCount += 2;
conn.outstandings.packetEvents.insert(packetNum1);
// A counting ack visitor
uint16_t ackVisitorCounter = 0;
@@ -682,10 +682,10 @@ TEST_P(AckHandlersTest, ClonedPacketsCounter) {
OutstandingPacket outstandingPacket2(
std::move(regularPacket2), Clock::now(), 1, false, 1);
conn.outstandingPackets.push_back(std::move(outstandingPacket1));
conn.outstandingPackets.push_back(std::move(outstandingPacket2));
conn.outstandingClonedPacketsCount = 1;
conn.outstandingPacketEvents.insert(packetNum1);
conn.outstandings.packets.push_back(std::move(outstandingPacket1));
conn.outstandings.packets.push_back(std::move(outstandingPacket2));
conn.outstandings.clonedPacketsCount = 1;
conn.outstandings.packetEvents.insert(packetNum1);
ReadAckFrame ackFrame;
ackFrame.largestAcked = packetNum2;
@@ -708,7 +708,7 @@ TEST_P(AckHandlersTest, ClonedPacketsCounter) {
PacketNum) { /* no-op */ },
Clock::now());
EXPECT_EQ(2, ackVisitorCounter);
EXPECT_EQ(0, conn.outstandingClonedPacketsCount);
EXPECT_EQ(0, conn.outstandings.clonedPacketsCount);
}
TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
@@ -718,7 +718,7 @@ TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
PacketNum packetNum = 0;
auto regularPacket = createNewPacket(packetNum, GetParam());
auto sentTime = Clock::now();
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
OutstandingPacket(std::move(regularPacket), sentTime, 1, false, 1));
ReadAckFrame ackFrame;
@@ -775,8 +775,8 @@ TEST_P(AckHandlersTest, AckNotOutstandingButLoss) {
1,
false,
1);
conn.outstandingPackets.push_back(std::move(outstandingPacket));
conn.outstandingClonedPacketsCount++;
conn.outstandings.packets.push_back(std::move(outstandingPacket));
conn.outstandings.clonedPacketsCount++;
EXPECT_CALL(*mockQLogger, addPacketsLost(1, 1, 1));
@@ -813,7 +813,7 @@ TEST_P(AckHandlersTest, UpdatePendingAckStates) {
PacketNum packetNum = 0;
auto regularPacket = createNewPacket(packetNum, GetParam());
auto sentTime = Clock::now() - 1500ms;
conn.outstandingPackets.emplace_back(OutstandingPacket(
conn.outstandings.packets.emplace_back(OutstandingPacket(
std::move(regularPacket),
sentTime,
111,
@@ -862,7 +862,7 @@ TEST_P(AckHandlersTest, AckEventCreation) {
false /* handshake */,
packetNum);
sentPacket.isAppLimited = (packetNum % 2);
conn.outstandingPackets.emplace_back(sentPacket);
conn.outstandings.packets.emplace_back(sentPacket);
packetNum++;
}

4
quic/state/test/QuicPacingFunctionsTest.cpp
View File

@@ -31,5 +31,5 @@ TEST_F(QuicPacingFunctionsTest, OnClose) {
EXPECT_FALSE(conn.canBePaced);
}
}
}
} // namespace test
} // namespace quic

10
quic/state/test/QuicStateFunctionsTest.cpp
View File

@@ -533,27 +533,27 @@ TEST_F(QuicStateFunctionsTest, IsConnectionPaced) {
TEST_F(QuicStateFunctionsTest, GetOutstandingPackets) {
QuicConnectionStateBase conn(QuicNodeType::Client);
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
makeTestLongPacket(LongHeader::Types::Initial),
Clock::now(),
135,
false,
0);
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
makeTestLongPacket(LongHeader::Types::Handshake),
Clock::now(),
1217,
false,
0);
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
makeTestShortPacket(), Clock::now(), 5556, false, 0);
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
makeTestLongPacket(LongHeader::Types::Initial),
Clock::now(),
56,
false,
0);
conn.outstandingPackets.emplace_back(
conn.outstandings.packets.emplace_back(
makeTestShortPacket(), Clock::now(), 6665, false, 0);
EXPECT_EQ(
135,