diff --git a/quic/api/QuicTransportFunctions.cpp b/quic/api/QuicTransportFunctions.cpp index 3e213b8e9..bf2fd1519 100644 --- a/quic/api/QuicTransportFunctions.cpp +++ b/quic/api/QuicTransportFunctions.cpp @@ -575,8 +575,7 @@ void updateConnection( VLOG(10) << nodeToString(conn.nodeType) << " sent conn window update in packetNum=" << packetNum << " " << conn; - onConnWindowUpdateSent( - conn, packetNum, maxDataFrame.maximumData, sentTime); + onConnWindowUpdateSent(conn, maxDataFrame.maximumData, sentTime); break; } case QuicWriteFrame::Type::DataBlockedFrame_E: { @@ -597,7 +596,7 @@ void updateConnection( << " sent packet with window update packetNum=" << packetNum << " stream=" << maxStreamDataFrame.streamId << " " << conn; onStreamWindowUpdateSent( - *stream, packetNum, maxStreamDataFrame.maximumData, sentTime); + *stream, maxStreamDataFrame.maximumData, sentTime); break; } case QuicWriteFrame::Type::StreamDataBlockedFrame_E: { @@ -1461,7 +1460,7 @@ void implicitAckCryptoStream( }, // We shouldn't mark anything as lost from the implicit ACK, as it should // be ACKing the entire rangee. - [](auto&, auto&, auto, auto) { + [](auto&, auto&, auto) { LOG(FATAL) << "Got loss from implicit crypto ACK."; }, implicitAckTime); diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp index 831b8eb1f..9b16ec500 100644 --- a/quic/api/test/QuicTransportBaseTest.cpp +++ b/quic/api/test/QuicTransportBaseTest.cpp @@ -2292,17 +2292,14 @@ TEST_F(QuicTransportImplTest, AsyncStreamFlowControlWrite) { auto stream = transport->createBidirectionalStream().value(); auto streamState = transport->transportConn->streamManager->getStream(stream); transport->setServerConnectionId(); - EXPECT_FALSE(streamState->latestMaxStreamDataPacket.has_value()); transport->writeLooper()->stop(); streamState->flowControlState.advertisedMaxOffset = 0; // Easier to calculate transport->setStreamFlowControlWindow(stream, 4000); EXPECT_EQ(0, streamState->flowControlState.advertisedMaxOffset); - EXPECT_FALSE(streamState->latestMaxStreamDataPacket.has_value()); // Loop it: EXPECT_TRUE(transport->writeLooper()->isRunning()); transport->writeLooper()->runLoopCallback(); EXPECT_EQ(4000, streamState->flowControlState.advertisedMaxOffset); - EXPECT_TRUE(streamState->latestMaxStreamDataPacket.has_value()); } TEST_F(QuicTransportImplTest, ExceptionInWriteLooperDoesNotCrash) { diff --git a/quic/api/test/QuicTransportFunctionsTest.cpp b/quic/api/test/QuicTransportFunctionsTest.cpp index 0a8bfd1b2..970c90e68 100644 --- a/quic/api/test/QuicTransportFunctionsTest.cpp +++ b/quic/api/test/QuicTransportFunctionsTest.cpp @@ -1023,7 +1023,6 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) { auto conn = createConn(); conn->qLogger = std::make_shared(VantagePoint::Client); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); - auto packetNum = packet.packet.header.getPacketSequenceNum(); auto stream = conn->streamManager->createNextBidirectionalStream().value(); MaxStreamDataFrame streamWindowUpdate(stream->id, 0); conn->streamManager->queueWindowUpdate(stream->id); @@ -1049,18 +1048,13 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) { auto frame = static_cast(event->frames[0].get()); EXPECT_EQ(frame->streamId, stream->id); EXPECT_EQ(frame->maximumData, 0); - - EXPECT_EQ(packetNum, *stream->latestMaxStreamDataPacket); - EXPECT_FALSE(conn->latestMaxDataPacket.has_value()); } TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) { auto conn = createConn(); conn->qLogger = std::make_shared(VantagePoint::Client); auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake); - auto packetNum = packet.packet.header.getPacketSequenceNum(); conn->pendingEvents.connWindowUpdate = true; - auto stream = conn->streamManager->createNextBidirectionalStream().value(); MaxDataFrame connWindowUpdate(conn->flowControlState.advertisedMaxOffset); packet.packet.frames.push_back(std::move(connWindowUpdate)); updateConnection( @@ -1082,9 +1076,6 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) { EXPECT_EQ(event->frames.size(), 1); auto frame = static_cast(event->frames[0].get()); EXPECT_EQ(frame->maximumData, conn->flowControlState.advertisedMaxOffset); - - EXPECT_FALSE(stream->latestMaxStreamDataPacket.has_value()); - EXPECT_EQ(packetNum, *conn->latestMaxDataPacket); } TEST_F(QuicTransportFunctionsTest, WriteQuicDataToSocketWithCC) { diff --git a/quic/api/test/QuicTransportTest.cpp b/quic/api/test/QuicTransportTest.cpp index 8d36e3326..cd3196bb5 100644 --- a/quic/api/test/QuicTransportTest.cpp +++ b/quic/api/test/QuicTransportTest.cpp @@ -1196,7 +1196,7 @@ TEST_F(QuicTransportTest, ResendPathChallengeOnLoss) { ->packet; EXPECT_FALSE(conn.pendingEvents.pathChallenge); - markPacketLoss(conn, packet, false, 2); + markPacketLoss(conn, packet, false); EXPECT_EQ(*conn.pendingEvents.pathChallenge, pathChallenge); } @@ -1221,7 +1221,7 @@ TEST_F(QuicTransportTest, DoNotResendLostPathChallengeIfNotOutstanding) { transport_->getPathValidationTimeout().timeoutExpired(); EXPECT_FALSE(conn.pendingEvents.pathChallenge); - markPacketLoss(conn, packet, false, 2); + markPacketLoss(conn, packet, false); EXPECT_FALSE(conn.pendingEvents.pathChallenge); } @@ -1332,7 +1332,7 @@ TEST_F(QuicTransportTest, DoNotResendPathResponseOnLoss) { auto packet = getLastOutstandingPacket(conn, PacketNumberSpace::AppData)->packet; - markPacketLoss(conn, packet, false, 2); + markPacketLoss(conn, packet, false); EXPECT_EQ(conn.pendingEvents.frames.size(), 0); } @@ -1469,7 +1469,7 @@ TEST_F(QuicTransportTest, ResendNewConnectionIdOnLoss) { ->packet; EXPECT_TRUE(conn.pendingEvents.frames.empty()); - markPacketLoss(conn, packet, false, 2); + markPacketLoss(conn, packet, false); EXPECT_EQ(conn.pendingEvents.frames.size(), 1); NewConnectionIdFrame* connIdFrame = conn.pendingEvents.frames.front().asNewConnectionIdFrame(); @@ -1557,7 +1557,7 @@ TEST_F(QuicTransportTest, ResendRetireConnectionIdOnLoss) { ->packet; EXPECT_TRUE(conn.pendingEvents.frames.empty()); - markPacketLoss(conn, packet, false, 2); + markPacketLoss(conn, packet, false); EXPECT_EQ(conn.pendingEvents.frames.size(), 1); RetireConnectionIdFrame* retireFrame = conn.pendingEvents.frames.front().asRetireConnectionIdFrame(); diff --git a/quic/congestion_control/test/BbrTest.cpp b/quic/congestion_control/test/BbrTest.cpp index ed01d129b..633b72760 100644 --- a/quic/congestion_control/test/BbrTest.cpp +++ b/quic/congestion_control/test/BbrTest.cpp @@ -553,7 +553,7 @@ TEST_F(BbrTest, BytesCounting) { ackFrame.largestAcked = packetNum; ackFrame.ackBlocks.emplace_back(packetNum, packetNum); auto ackVisitor = [&](auto&, auto&, auto&) {}; - auto lossVisitor = [&](auto&, auto&, bool, PacketNum) {}; + auto lossVisitor = [&](auto&, auto&, bool) {}; processAckFrame( conn, PacketNumberSpace::AppData, diff --git a/quic/fizz/client/test/QuicClientTransportTest.cpp b/quic/fizz/client/test/QuicClientTransportTest.cpp index 9e16c338d..41e00e401 100644 --- a/quic/fizz/client/test/QuicClientTransportTest.cpp +++ b/quic/fizz/client/test/QuicClientTransportTest.cpp @@ -4706,8 +4706,7 @@ TEST_F(QuicClientTransportAfterStartTest, ResetClearsPendingLoss) { RegularQuicWritePacket* forceLossPacket = CHECK_NOTNULL(findPacketWithStream(client->getNonConstConn(), streamId)); - auto packetNum = forceLossPacket->header.getPacketSequenceNum(); - markPacketLoss(client->getNonConstConn(), *forceLossPacket, false, packetNum); + markPacketLoss(client->getNonConstConn(), *forceLossPacket, false); auto& pendingLossStreams = client->getConn().streamManager->lossStreams(); auto it = std::find(pendingLossStreams.begin(), pendingLossStreams.end(), streamId); @@ -4733,8 +4732,7 @@ TEST_F(QuicClientTransportAfterStartTest, LossAfterResetStream) { RegularQuicWritePacket* forceLossPacket = CHECK_NOTNULL(findPacketWithStream(client->getNonConstConn(), streamId)); - auto packetNum = forceLossPacket->header.getPacketSequenceNum(); - markPacketLoss(client->getNonConstConn(), *forceLossPacket, false, packetNum); + markPacketLoss(client->getNonConstConn(), *forceLossPacket, false); auto stream = CHECK_NOTNULL( client->getNonConstConn().streamManager->getStream(streamId)); ASSERT_TRUE(stream->lossBuffer.empty()); diff --git a/quic/flowcontrol/QuicFlowController.cpp b/quic/flowcontrol/QuicFlowController.cpp index 554e50f3e..5cfbf5aa9 100644 --- a/quic/flowcontrol/QuicFlowController.cpp +++ b/quic/flowcontrol/QuicFlowController.cpp @@ -362,12 +362,9 @@ uint64_t getRecvConnFlowControlBytes(const QuicConnectionStateBase& conn) { void onConnWindowUpdateSent( QuicConnectionStateBase& conn, - PacketNum packetNum, uint64_t maximumDataSent, TimePoint sentTime) { DCHECK_GE(maximumDataSent, conn.flowControlState.advertisedMaxOffset); - DCHECK_LE(conn.latestMaxDataPacket.value_or(packetNum), packetNum); - conn.latestMaxDataPacket = packetNum; conn.flowControlState.advertisedMaxOffset = maximumDataSent; conn.flowControlState.timeOfLastFlowControlUpdate = sentTime; conn.pendingEvents.connWindowUpdate = false; @@ -376,11 +373,8 @@ void onConnWindowUpdateSent( void onStreamWindowUpdateSent( QuicStreamState& stream, - PacketNum packetNum, uint64_t maximumDataSent, TimePoint sentTime) { - DCHECK_LE(stream.latestMaxStreamDataPacket.value_or(packetNum), packetNum); - stream.latestMaxStreamDataPacket = packetNum; stream.flowControlState.advertisedMaxOffset = maximumDataSent; stream.flowControlState.timeOfLastFlowControlUpdate = sentTime; stream.conn.streamManager->removeWindowUpdate(stream.id); diff --git a/quic/flowcontrol/QuicFlowController.h b/quic/flowcontrol/QuicFlowController.h index 4c882632b..6b0e4ece7 100644 --- a/quic/flowcontrol/QuicFlowController.h +++ b/quic/flowcontrol/QuicFlowController.h @@ -60,13 +60,11 @@ void handleConnBlocked(QuicConnectionStateBase& conn); void onStreamWindowUpdateSent( QuicStreamState& stream, - PacketNum packetNum, uint64_t maximumData, TimePoint sentTime); void onConnWindowUpdateSent( QuicConnectionStateBase& conn, - PacketNum pacektNum, uint64_t maximumData, TimePoint sentTime); diff --git a/quic/flowcontrol/test/QuicFlowControlTest.cpp b/quic/flowcontrol/test/QuicFlowControlTest.cpp index 3bbcb69a6..719da13b2 100644 --- a/quic/flowcontrol/test/QuicFlowControlTest.cpp +++ b/quic/flowcontrol/test/QuicFlowControlTest.cpp @@ -157,21 +157,13 @@ TEST_F(QuicFlowControlTest, GenerateMaxDataFrameChangeWindowLarger) { conn_.flowControlState.sumCurReadOffset = 301; auto frame = generateMaxDataFrame(conn_); EXPECT_EQ(801, frame.maximumData); - onConnWindowUpdateSent( - conn_, - conn_.ackStates.appDataAckState.nextPacketNum, - frame.maximumData, - Clock::now()); + onConnWindowUpdateSent(conn_, frame.maximumData, Clock::now()); EXPECT_EQ(801, conn_.flowControlState.advertisedMaxOffset); conn_.flowControlState.windowSize = 1001; auto frame2 = generateMaxDataFrame(conn_); EXPECT_EQ(1302, frame2.maximumData); - onConnWindowUpdateSent( - conn_, - conn_.ackStates.appDataAckState.nextPacketNum, - frame2.maximumData, - Clock::now()); + onConnWindowUpdateSent(conn_, frame2.maximumData, Clock::now()); EXPECT_EQ( frame2.maximumData, conn_.flowControlState.sumCurReadOffset + @@ -262,13 +254,7 @@ TEST_F(QuicFlowControlTest, MaybeSendStreamWindowUpdateChangeWindowSmaller) { ASSERT_TRUE(conn_.streamManager->pendingWindowUpdate(stream.id)); auto sendTime = Clock::now(); onStreamWindowUpdateSent( - stream, - conn_.ackStates.appDataAckState.nextPacketNum, - generateMaxStreamDataFrame(stream).maximumData, - sendTime); - EXPECT_EQ( - conn_.ackStates.appDataAckState.nextPacketNum, - *stream.latestMaxStreamDataPacket); + stream, generateMaxStreamDataFrame(stream).maximumData, sendTime); stream.flowControlState.windowSize = 10; // change the read bytes to be within the maybeSendUpdate size of the previous @@ -346,13 +332,7 @@ TEST_F(QuicFlowControlTest, MaybeSendStreamWindowUpdateChangeWindowLarger) { maybeSendStreamWindowUpdate(stream, Clock::now()); EXPECT_TRUE(conn_.streamManager->pendingWindowUpdate(stream.id)); onStreamWindowUpdateSent( - stream, - conn_.ackStates.appDataAckState.nextPacketNum, - generateMaxStreamDataFrame(stream).maximumData, - Clock::now()); - EXPECT_EQ( - conn_.ackStates.appDataAckState.nextPacketNum, - *stream.latestMaxStreamDataPacket); + stream, generateMaxStreamDataFrame(stream).maximumData, Clock::now()); EXPECT_FALSE(conn_.streamManager->pendingWindowUpdate(stream.id)); stream.flowControlState.windowSize = 1001; @@ -378,14 +358,7 @@ TEST_F(QuicFlowControlTest, SendingConnectionWindowUpdate) { // Clear out the window update. auto sendTime = Clock::now(); - onConnWindowUpdateSent( - conn_, - conn_.ackStates.appDataAckState.nextPacketNum, - frameOffset, - sendTime); - EXPECT_EQ( - conn_.ackStates.appDataAckState.nextPacketNum, - *conn_.latestMaxDataPacket); + onConnWindowUpdateSent(conn_, frameOffset, sendTime); EXPECT_FALSE(conn_.pendingEvents.connWindowUpdate); EXPECT_EQ(conn_.flowControlState.advertisedMaxOffset, frameOffset); EXPECT_EQ(*conn_.flowControlState.timeOfLastFlowControlUpdate, sendTime); @@ -406,14 +379,7 @@ TEST_F(QuicFlowControlTest, SendingStreamWindowUpdate) { EXPECT_EQ(800, frameOffset); auto sendTime = Clock::now(); - onStreamWindowUpdateSent( - stream, - conn_.ackStates.appDataAckState.nextPacketNum, - frameOffset, - sendTime); - EXPECT_EQ( - conn_.ackStates.appDataAckState.nextPacketNum, - *stream.latestMaxStreamDataPacket); + onStreamWindowUpdateSent(stream, frameOffset, sendTime); EXPECT_FALSE(conn_.streamManager->pendingWindowUpdate(stream.id)); EXPECT_EQ(stream.flowControlState.advertisedMaxOffset, frameOffset); EXPECT_EQ(*stream.flowControlState.timeOfLastFlowControlUpdate, sendTime); @@ -844,11 +810,7 @@ TEST_F(QuicFlowControlTest, OnConnWindowUpdateSentWithoutPendingEvent) { conn_.flowControlState.windowSize = 1000; conn_.flowControlState.advertisedMaxOffset = 0; conn_.flowControlState.sumCurReadOffset = 0; - onConnWindowUpdateSent( - conn_, conn_.ackStates.appDataAckState.nextPacketNum, 1000, Clock::now()); - EXPECT_EQ( - conn_.ackStates.appDataAckState.nextPacketNum, - *conn_.latestMaxDataPacket); + onConnWindowUpdateSent(conn_, 1000, Clock::now()); EXPECT_EQ(1000, conn_.flowControlState.advertisedMaxOffset); EXPECT_FALSE(conn_.pendingEvents.connWindowUpdate); } @@ -859,14 +821,7 @@ TEST_F(QuicFlowControlTest, OnStreamWindowUpdateSentWithoutPendingEvent) { stream.currentReadOffset = 0; stream.flowControlState.advertisedMaxOffset = 0; stream.flowControlState.windowSize = 1000; - onStreamWindowUpdateSent( - stream, - conn_.ackStates.appDataAckState.nextPacketNum, - 1000, - Clock::now()); - EXPECT_EQ( - conn_.ackStates.appDataAckState.nextPacketNum, - *stream.latestMaxStreamDataPacket); + onStreamWindowUpdateSent(stream, 1000, Clock::now()); EXPECT_EQ(1000, stream.flowControlState.advertisedMaxOffset); EXPECT_FALSE(conn_.streamManager->pendingWindowUpdate(id)); } diff --git a/quic/loss/QuicLossFunctions.cpp b/quic/loss/QuicLossFunctions.cpp index adf54b575..8ca79487e 100644 --- a/quic/loss/QuicLossFunctions.cpp +++ b/quic/loss/QuicLossFunctions.cpp @@ -63,8 +63,7 @@ void onPTOAlarm(QuicConnectionStateBase& conn) { void markPacketLoss( QuicConnectionStateBase& conn, RegularQuicWritePacket& packet, - bool processed, - PacketNum currentPacketNum) { + bool processed) { QUIC_STATS(conn.statsCallback, onPacketLoss); for (auto& packetFrame : packet.frames) { switch (packetFrame.type()) { @@ -72,26 +71,19 @@ void markPacketLoss( MaxStreamDataFrame& frame = *packetFrame.asMaxStreamDataFrame(); // For all other frames, we process it if it's not from a clone // packet, or if the clone and its siblings have never been processed. - // But for both MaxData and MaxStreamData, clone and its siblings may - // have different values. So we process it if it matches the - // latestMaxDataPacket or latestMaxStreamDataPacket. If an older - // packet also has such frames, it's ok to skip process of such loss - // since newer value is already sent in later packets. + // But for both MaxData and MaxStreamData, we opportunistically send + // an update to avoid stalling the peer. auto stream = conn.streamManager->getStream(frame.streamId); if (!stream) { break; } // TODO: check for the stream is in Open or HalfClosedLocal state, the // peer doesn't need a flow control update in these cases. - if (stream->latestMaxStreamDataPacket == currentPacketNum) { - onStreamWindowUpdateLost(*stream); - } + onStreamWindowUpdateLost(*stream); break; } case QuicWriteFrame::Type::MaxDataFrame_E: { - if (conn.latestMaxDataPacket == currentPacketNum) { - onConnWindowUpdateLost(conn); - } + onConnWindowUpdateLost(conn); break; } // For other frame types, we only process them if the packet is not a diff --git a/quic/loss/QuicLossFunctions.h b/quic/loss/QuicLossFunctions.h index b87d657e2..7a75dbaa5 100644 --- a/quic/loss/QuicLossFunctions.h +++ b/quic/loss/QuicLossFunctions.h @@ -236,7 +236,7 @@ folly::Optional detectLossPackets( // or if the PacketEvent is present in conn.outstandings.packetEvents. bool processed = pkt.associatedEvent && !conn.outstandings.packetEvents.count(*pkt.associatedEvent); - lossVisitor(conn, pkt.packet, processed, currentPacketNum); + lossVisitor(conn, pkt.packet, processed); // Remove the PacketEvent from the outstandings.packetEvents set if (pkt.associatedEvent) { conn.outstandings.packetEvents.erase(*pkt.associatedEvent); @@ -354,8 +354,7 @@ void onLossDetectionAlarm( void markPacketLoss( QuicConnectionStateBase& conn, RegularQuicWritePacket& packet, - bool processed, - PacketNum currentPacketNum); + bool processed); template folly::Optional handleAckForLoss( @@ -408,10 +407,9 @@ void markZeroRttPacketsLost( if (isZeroRttPacket) { auto& pkt = *iter; DCHECK(!pkt.isHandshake); - auto currentPacketNum = pkt.packet.header.getPacketSequenceNum(); bool processed = pkt.associatedEvent && !conn.outstandings.packetEvents.count(*pkt.associatedEvent); - lossVisitor(conn, pkt.packet, processed, currentPacketNum); + lossVisitor(conn, pkt.packet, processed); // Remove the PacketEvent from the outstandings.packetEvents set if (pkt.associatedEvent) { conn.outstandings.packetEvents.erase(*pkt.associatedEvent); diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp index 511c16045..237874318 100644 --- a/quic/loss/test/QuicLossFunctionsTest.cpp +++ b/quic/loss/test/QuicLossFunctionsTest.cpp @@ -124,8 +124,7 @@ class QuicLossFunctionsTest : public TestWithParam { }; auto testingLossMarkFunc(std::vector& lostPackets) { - return [&lostPackets]( - auto& /* conn */, auto& packet, bool processed, PacketNum) { + return [&lostPackets](auto& /* conn */, auto& packet, bool processed) { if (!processed) { auto packetNum = packet.header.getPacketSequenceNum(); lostPackets.push_back(packetNum); @@ -279,7 +278,7 @@ TEST_F(QuicLossFunctionsTest, ClearEarlyRetranTimer) { ASSERT_GT(secondPacketNum, firstPacketNum); ASSERT_EQ(2, conn->outstandings.packets.size()); // detectLossPackets will set lossTime on Initial space. - auto lossVisitor = [](auto&, auto&, bool, PacketNum) { ASSERT_FALSE(true); }; + auto lossVisitor = [](auto&, auto&, bool) { ASSERT_FALSE(true); }; detectLossPackets( *conn, secondPacketNum, @@ -420,8 +419,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLoss) { EXPECT_EQ(1, conn->outstandings.packets.size()); auto& packet = getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet; - auto packetNum = packet.header.getPacketSequenceNum(); - markPacketLoss(*conn, packet, false, packetNum); + markPacketLoss(*conn, packet, false); EXPECT_EQ(stream1->retransmissionBuffer.size(), 0); EXPECT_EQ(stream2->retransmissionBuffer.size(), 0); EXPECT_EQ(stream1->lossBuffer.size(), 1); @@ -471,13 +469,13 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossMerge) { auto& packet1 = getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet; auto packetNum = packet1.header.getPacketSequenceNum(); - markPacketLoss(*conn, packet1, false, packetNum); + markPacketLoss(*conn, packet1, false); EXPECT_EQ(stream1->retransmissionBuffer.size(), 1); EXPECT_EQ(stream1->lossBuffer.size(), 1); auto& packet2 = getLastOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet; packetNum = packet2.header.getPacketSequenceNum(); - markPacketLoss(*conn, packet2, false, packetNum); + markPacketLoss(*conn, packet2, false); EXPECT_EQ(stream1->retransmissionBuffer.size(), 0); EXPECT_EQ(stream1->lossBuffer.size(), 1); @@ -540,13 +538,13 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossNoMerge) { auto& packet1 = getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet; auto packetNum = packet1.header.getPacketSequenceNum(); - markPacketLoss(*conn, packet1, false, packetNum); + markPacketLoss(*conn, packet1, false); EXPECT_EQ(stream1->retransmissionBuffer.size(), 2); EXPECT_EQ(stream1->lossBuffer.size(), 1); auto& packet3 = getLastOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet; packetNum = packet3.header.getPacketSequenceNum(); - markPacketLoss(*conn, packet3, false, packetNum); + markPacketLoss(*conn, packet3, false); EXPECT_EQ(stream1->retransmissionBuffer.size(), 1); EXPECT_EQ(stream1->lossBuffer.size(), 2); @@ -592,8 +590,7 @@ TEST_F(QuicLossFunctionsTest, RetxBufferSortedAfterLoss) { EXPECT_EQ(3, stream->retransmissionBuffer.size()); 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()); + markPacketLoss(*conn, packet.packet, false); EXPECT_EQ(2, stream->retransmissionBuffer.size()); } @@ -624,9 +621,8 @@ TEST_F(QuicLossFunctionsTest, TestMarkCryptoLostAfterCancelRetransmission) { ASSERT_EQ(conn->outstandings.packets.size(), 1); EXPECT_GT(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0); auto& packet = conn->outstandings.packets.front().packet; - auto packetNum = packet.header.getPacketSequenceNum(); cancelHandshakeCryptoStreamRetransmissions(*conn->cryptoState); - markPacketLoss(*conn, packet, false, packetNum); + markPacketLoss(*conn, packet, false); EXPECT_EQ(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0); EXPECT_EQ(conn->cryptoState->handshakeStream.lossBuffer.size(), 0); } @@ -658,8 +654,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkCryptoLostCancel) { ASSERT_EQ(conn->outstandings.packets.size(), 1); EXPECT_GT(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0); auto& packet = conn->outstandings.packets.front().packet; - auto packetNum = packet.header.getPacketSequenceNum(); - markPacketLoss(*conn, packet, false, packetNum); + markPacketLoss(*conn, packet, false); EXPECT_EQ(conn->cryptoState->handshakeStream.retransmissionBuffer.size(), 0); EXPECT_EQ(conn->cryptoState->handshakeStream.lossBuffer.size(), 1); cancelHandshakeCryptoStreamRetransmissions(*conn->cryptoState); @@ -684,7 +679,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossAfterStreamReset) { true); sendRstSMHandler(*stream1, GenericApplicationErrorCode::UNKNOWN); - markPacketLoss(*conn, packet, false, packet.header.getPacketSequenceNum()); + markPacketLoss(*conn, packet, false); EXPECT_TRUE(stream1->lossBuffer.empty()); EXPECT_TRUE(stream1->retransmissionBuffer.empty()); @@ -701,11 +696,10 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) { EXPECT_CALL(*rawCongestionController, onPacketSent(_)) .WillRepeatedly(Return()); - auto testingLossMarkFunc = - [&lostPacket](auto& /*conn*/, auto& packet, bool, PacketNum) { - auto packetNum = packet.header.getPacketSequenceNum(); - lostPacket.push_back(packetNum); - }; + auto testingLossMarkFunc = [&lostPacket](auto& /*conn*/, auto& packet, bool) { + auto packetNum = packet.header.getPacketSequenceNum(); + lostPacket.push_back(packetNum); + }; for (int i = 0; i < 6; ++i) { sendPacket(*conn, Clock::now(), folly::none, PacketType::Handshake); } @@ -771,7 +765,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) { OutstandingPacket(outstandingRegularPacket, now, 0, false, 0)); bool testLossMarkFuncCalled = false; - auto testLossMarkFunc = [&](auto& /* conn */, auto&, bool, PacketNum) { + auto testLossMarkFunc = [&](auto& /* conn */, auto&, bool) { testLossMarkFuncCalled = true; }; EXPECT_CALL(*mockQLogger, addPacketsLost(1, 0, 1)); @@ -809,7 +803,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckedPacket) { conn->lossState.largestSent.value_or(0)); bool testLossMarkFuncCalled = false; - auto testLossMarkFunc = [&](auto& /* conn */, auto&, bool, PacketNum) { + auto testLossMarkFunc = [&](auto& /* conn */, auto&, bool) { testLossMarkFuncCalled = true; }; @@ -858,7 +852,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkRstLoss) { EXPECT_TRUE(conn->pendingEvents.resets.empty()); auto& packet = getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet; - markPacketLoss(*conn, packet, false, packet.header.getPacketSequenceNum()); + markPacketLoss(*conn, packet, false); EXPECT_EQ(1, conn->pendingEvents.resets.size()); EXPECT_EQ(1, conn->pendingEvents.resets.count(stream->id)); @@ -897,14 +891,12 @@ TEST_F(QuicLossFunctionsTest, TestMarkRstLoss) { TEST_F(QuicLossFunctionsTest, ReorderingThresholdChecksSamePacketNumberSpace) { auto conn = createConn(); uint16_t lossVisitorCount = 0; - auto countingLossVisitor = [&](auto& /* conn */, - auto& /* packet */, - bool processed, - PacketNum /* currentPacketNum */) { - if (!processed) { - lossVisitorCount++; - } - }; + auto countingLossVisitor = + [&](auto& /* conn */, auto& /* packet */, bool processed) { + if (!processed) { + lossVisitorCount++; + } + }; PacketNum latestSent = 0; for (size_t i = 0; i < conn->lossState.reorderingThreshold + 1; i++) { latestSent = @@ -950,8 +942,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkWindowUpdateLoss) { auto& packet = getFirstOutstandingPacket(*conn, PacketNumberSpace::AppData)->packet; - auto packetNum = packet.header.getPacketSequenceNum(); - markPacketLoss(*conn, packet, false, packetNum); + markPacketLoss(*conn, packet, false); EXPECT_TRUE(conn->streamManager->pendingWindowUpdate(stream->id)); } @@ -1178,14 +1169,12 @@ TEST_F(QuicLossFunctionsTest, NoSkipLossVisitor) { // make srtt large so delayUntilLost won't kick in conn->lossState.srtt = 1000000000us; uint16_t lossVisitorCount = 0; - auto countingLossVisitor = [&](auto& /* conn */, - auto& /* packet */, - bool processed, - PacketNum /* currentPacketNum */) { - if (!processed) { - lossVisitorCount++; - } - }; + auto countingLossVisitor = + [&](auto& /* conn */, auto& /* packet */, bool processed) { + if (!processed) { + lossVisitorCount++; + } + }; // Send 5 packets, so when we ack the last one, we mark the first one loss PacketNum lastSent; for (size_t i = 0; i < 5; i++) { @@ -1206,14 +1195,12 @@ TEST_F(QuicLossFunctionsTest, SkipLossVisitor) { // make srtt large so delayUntilLost won't kick in conn->lossState.srtt = 1000000000us; uint16_t lossVisitorCount = 0; - auto countingLossVisitor = [&](auto& /* conn */, - auto& /* packet */, - bool processed, - PacketNum /* currentPacketNum */) { - if (!processed) { - lossVisitorCount++; - } - }; + auto countingLossVisitor = + [&](auto& /* conn */, auto& /* packet */, bool processed) { + if (!processed) { + lossVisitorCount++; + } + }; // Send 5 packets, so when we ack the last one, we mark the first one loss PacketNum lastSent; for (size_t i = 0; i < 5; i++) { @@ -1237,14 +1224,12 @@ TEST_F(QuicLossFunctionsTest, NoDoubleProcess) { conn->lossState.srtt = 1000000000us; uint16_t lossVisitorCount = 0; - auto countingLossVisitor = [&](auto& /* conn */, - auto& /* packet */, - bool processed, - PacketNum /* currentPacketNum */) { - if (!processed) { - lossVisitorCount++; - } - }; + auto countingLossVisitor = + [&](auto& /* conn */, auto& /* packet */, bool processed) { + if (!processed) { + lossVisitorCount++; + } + }; // Send 6 packets, so when we ack the last one, we mark the first two loss PacketNum lastSent; PacketEvent event(PacketNumberSpace::AppData, 0); @@ -1283,7 +1268,7 @@ TEST_F(QuicLossFunctionsTest, DetectPacketLossClonedPacketsCounter) { sendPacket(*conn, Clock::now(), folly::none, PacketType::OneRtt); auto ackedPacket = sendPacket(*conn, Clock::now(), folly::none, PacketType::OneRtt); - auto noopLossMarker = [](auto&, auto&, bool, PacketNum) {}; + auto noopLossMarker = [](auto&, auto&, bool) {}; detectLossPackets( *conn, ackedPacket, @@ -1305,7 +1290,6 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) { conn->streamManager->createNextBidirectionalStream().value()->id; conn->streamManager->queueWindowUpdate(stream2Id); conn->pendingEvents.connWindowUpdate = true; - auto nextPacketNum = conn->ackStates.appDataAckState.nextPacketNum; // writeQuicPacket will call writeQuicDataToSocket which will also take care // of sending the MaxStreamDataFrame for stream2 auto stream1 = conn->streamManager->findStream(stream1Id); @@ -1345,7 +1329,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) { EXPECT_EQ(1, streamWindowUpdateCounter); EXPECT_EQ(1, connWindowUpdateCounter); // Force this packet to be a processed clone - markPacketLoss(*conn, packet, true, nextPacketNum); + markPacketLoss(*conn, packet, true); EXPECT_EQ(1, stream1->retransmissionBuffer.size()); EXPECT_TRUE(stream1->lossBuffer.empty()); @@ -1389,14 +1373,12 @@ TEST_F(QuicLossFunctionsTest, TotalLossCount) { } EXPECT_EQ(10, conn->outstandings.packets.size()); uint32_t lostPackets = 0; - auto countingLossVisitor = [&](auto& /* conn */, - auto& /* packet */, - bool processed, - PacketNum /* currentPacketNum */) { - if (!processed) { - lostPackets++; - } - }; + auto countingLossVisitor = + [&](auto& /* conn */, auto& /* packet */, bool processed) { + if (!processed) { + lostPackets++; + } + }; conn->lossState.rtxCount = 135; detectLossPackets( @@ -1423,17 +1405,16 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejected) { } EXPECT_FALSE(conn->outstandings.packets.empty()); EXPECT_EQ(4, conn->outstandings.packets.size()); - std::vector> lostPackets; + std::vector lostPackets; // onRemoveBytesFromInflight should still happen EXPECT_CALL(*rawCongestionController, onRemoveBytesFromInflight(_)).Times(1); - markZeroRttPacketsLost( - *conn, [&lostPackets](auto&, auto&, bool processed, PacketNum packetNum) { - lostPackets.emplace_back(packetNum, processed); - }); + markZeroRttPacketsLost(*conn, [&lostPackets](auto&, auto&, bool processed) { + lostPackets.emplace_back(processed); + }); EXPECT_EQ(2, conn->outstandings.packets.size()); EXPECT_EQ(lostPackets.size(), 2); for (auto lostPacket : lostPackets) { - EXPECT_FALSE(lostPacket.second); + EXPECT_FALSE(lostPacket); } for (size_t i = 0; i < conn->outstandings.packets.size(); ++i) { auto longHeader = conn->outstandings.packets[i].packet.header.asLong(); @@ -1473,20 +1454,19 @@ TEST_F(QuicLossFunctionsTest, TestZeroRttRejectedWithClones) { ASSERT_EQ(conn->outstandings.clonedPacketsCount, 6); ASSERT_EQ(conn->outstandings.packetEvents.size(), 2); - std::vector> lostPackets; + std::vector lostPackets; // onRemoveBytesFromInflight should still happen EXPECT_CALL(*rawCongestionController, onRemoveBytesFromInflight(_)).Times(1); - markZeroRttPacketsLost( - *conn, [&lostPackets](auto&, auto&, bool processed, PacketNum packetNum) { - lostPackets.emplace_back(packetNum, processed); - }); + markZeroRttPacketsLost(*conn, [&lostPackets](auto&, auto&, bool processed) { + lostPackets.emplace_back(processed); + }); ASSERT_EQ(conn->outstandings.packetEvents.size(), 0); EXPECT_EQ(3, conn->outstandings.packets.size()); EXPECT_EQ(lostPackets.size(), 3); ASSERT_EQ(conn->outstandings.clonedPacketsCount, 3); size_t numProcessed = 0; for (auto lostPacket : lostPackets) { - numProcessed += lostPacket.second; + numProcessed += lostPacket; } EXPECT_EQ(numProcessed, 1); for (size_t i = 0; i < conn->outstandings.packets.size(); ++i) { @@ -1521,11 +1501,8 @@ TEST_F(QuicLossFunctionsTest, TimeThreshold) { referenceTime + conn->lossState.srtt / 2, folly::none, PacketType::OneRtt); - auto lossVisitor = [&](const auto& /*conn*/, - const auto& /*packet*/, - bool, - PacketNum packetNum) { - EXPECT_EQ(packet1, packetNum); + auto lossVisitor = [&](const auto& /*conn*/, const auto& packet, bool) { + EXPECT_EQ(packet1, packet.header.getPacketSequenceNum()); }; detectLossPackets( *conn, @@ -1545,10 +1522,9 @@ TEST_F(QuicLossFunctionsTest, OutstandingInitialCounting) { sendPacket(*conn, Clock::now(), folly::none, PacketType::Initial); } EXPECT_EQ(10, conn->outstandings.initialPacketsCount); - auto noopLossVisitor = [&](auto& /* conn */, - auto& /* packet */, - bool /* processed */, - PacketNum /* currentPacketNum */) {}; + auto noopLossVisitor = + [&](auto& /* conn */, auto& /* packet */, bool /* processed */ + ) {}; detectLossPackets( *conn, largestSent, @@ -1569,10 +1545,9 @@ TEST_F(QuicLossFunctionsTest, OutstandingHandshakeCounting) { sendPacket(*conn, Clock::now(), folly::none, PacketType::Handshake); } EXPECT_EQ(10, conn->outstandings.handshakePacketsCount); - auto noopLossVisitor = [&](auto& /* conn */, - auto& /* packet */, - bool /* processed */, - PacketNum /* currentPacketNum */) {}; + auto noopLossVisitor = + [&](auto& /* conn */, auto& /* packet */, bool /* processed */ + ) {}; detectLossPackets( *conn, largestSent, diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp index 4c06571fb..5246c7598 100644 --- a/quic/server/test/QuicServerTransportTest.cpp +++ b/quic/server/test/QuicServerTransportTest.cpp @@ -1733,11 +1733,7 @@ TEST_F(QuicServerTransportTest, StopSendingLoss) { ASSERT_TRUE(builder.canBuildPacket()); writeFrame(QuicSimpleFrame(stopSendingFrame), builder); auto packet = std::move(builder).buildPacket(); - markPacketLoss( - server->getNonConstConn(), - packet.packet, - false, - clientNextAppDataPacketNum); + markPacketLoss(server->getNonConstConn(), packet.packet, false); EXPECT_EQ(server->getNonConstConn().pendingEvents.frames.size(), 1); StopSendingFrame* stopFrame = server->getNonConstConn() .pendingEvents.frames.front() @@ -1769,11 +1765,7 @@ TEST_F(QuicServerTransportTest, StopSendingLossAfterStreamClosed) { // clear out all the streams, this is not a great way to simulate closed // streams, but good enough for this test. server->getNonConstConn().streamManager->clearOpenStreams(); - markPacketLoss( - server->getNonConstConn(), - packet.packet, - false, - server->getNonConstConn().ackStates.appDataAckState.nextPacketNum); + markPacketLoss(server->getNonConstConn(), packet.packet, false); EXPECT_EQ(server->getNonConstConn().pendingEvents.frames.size(), 0); } diff --git a/quic/state/AckHandlers.h b/quic/state/AckHandlers.h index 2ea214aef..c6e94f084 100644 --- a/quic/state/AckHandlers.h +++ b/quic/state/AckHandlers.h @@ -19,7 +19,7 @@ using AckVisitor = std::function< void(const OutstandingPacket&, const QuicWriteFrame&, const ReadAckFrame&)>; using LossVisitor = std::function< - void(QuicConnectionStateBase&, RegularQuicWritePacket&, bool, PacketNum)>; + void(QuicConnectionStateBase&, RegularQuicWritePacket&, bool)>; /** * Processes an ack frame and removes any outstanding packets diff --git a/quic/state/StateData.h b/quic/state/StateData.h index 4f5f072ca..67be57598 100644 --- a/quic/state/StateData.h +++ b/quic/state/StateData.h @@ -757,10 +757,6 @@ struct QuicConnectionStateBase : public folly::DelayedDestruction { PacketSchedulingState schedulingState; - // The packet number of the latest packet that contains a MaxDataFrame sent - // out by us. - folly::Optional latestMaxDataPacket; - // Logger for this connection. std::shared_ptr logger; diff --git a/quic/state/StreamData.h b/quic/state/StreamData.h index 52987bade..57fc431d3 100644 --- a/quic/state/StreamData.h +++ b/quic/state/StreamData.h @@ -193,10 +193,6 @@ struct QuicStreamState : public QuicStreamLike { // State machine data StreamRecvState recvState{StreamRecvState::Open_E}; - // The packet number of the latest packet that contains a MaxStreamDataFrame - // sent out by us. - folly::Optional latestMaxStreamDataPacket; - // Tells whether this stream is a control stream. // It is set by the app via setControlStream and the transport can use this // knowledge for optimizations e.g. for setting the app limited state on diff --git a/quic/state/test/AckHandlersTest.cpp b/quic/state/test/AckHandlersTest.cpp index b32ece151..2ecc035d2 100644 --- a/quic/state/test/AckHandlersTest.cpp +++ b/quic/state/test/AckHandlersTest.cpp @@ -28,11 +28,10 @@ namespace test { class AckHandlersTest : public TestWithParam {}; auto testLossHandler(std::vector& lostPackets) -> decltype(auto) { - return - [&lostPackets](QuicConnectionStateBase&, auto& packet, bool, PacketNum) { - auto packetNum = packet.header.getPacketSequenceNum(); - lostPackets.push_back(packetNum); - }; + return [&lostPackets](QuicConnectionStateBase&, auto& packet, bool) { + auto packetNum = packet.header.getPacketSequenceNum(); + lostPackets.push_back(packetNum); + }; } TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocks) { @@ -214,7 +213,7 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocksLoss) { GetParam(), ackFrame, [](auto, auto, auto) {}, - [](auto&, auto&, auto, auto) {}, + [](auto&, auto&, auto) {}, Clock::now()); itr = std::find_if( conn.outstandings.packets.begin(), @@ -231,7 +230,7 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocksLoss) { GetParam(), ackFrame, [](auto, auto, auto) {}, - [](auto&, auto&, auto, auto) {}, + [](auto&, auto&, auto) {}, Clock::now() + 2 * calculatePTO(conn)); numDeclaredLost = std::count_if( @@ -477,10 +476,8 @@ TEST_P(AckHandlersTest, AckVisitorForAckTest) { commonAckVisitorForAckFrame(conn.ackStates.appDataAckState, *frame); } }, - [](auto& /* conn */, - auto& /* packet */, - bool /* processed */, - PacketNum /* currentPacketNum */) {}, + [](auto& /* conn */, auto& /* packet */, bool /* processed */ + ) {}, Clock::now()); EXPECT_EQ(2, conn.ackStates.appDataAckState.acks.size()); EXPECT_EQ( @@ -503,10 +500,8 @@ TEST_P(AckHandlersTest, AckVisitorForAckTest) { commonAckVisitorForAckFrame(conn.ackStates.appDataAckState, *frame); } }, - [](auto& /* conn */, - auto& /* packet */, - bool /* processed */, - PacketNum /* currentPacketNum */) {}, + [](auto& /* conn */, auto& /* packet */, bool /* processed */ + ) {}, Clock::now()); EXPECT_TRUE(conn.ackStates.appDataAckState.acks.empty()); } @@ -532,7 +527,7 @@ TEST_P(AckHandlersTest, NoNewAckedPacket) { GetParam(), ackFrame, [](const auto&, const auto&, const auto&) {}, - [](auto&, auto&, bool, PacketNum) {}, + [](auto&, auto&, bool) {}, Clock::now()); EXPECT_TRUE(conn.pendingEvents.setLossDetectionAlarm); EXPECT_EQ(conn.lossState.ptoCount, 1); @@ -553,7 +548,7 @@ TEST_P(AckHandlersTest, LossByAckedRecovered) { GetParam(), ackFrame, [](const auto&, const auto&, const auto&) {}, - [](auto&, auto&, bool, PacketNum) {}, + [](auto&, auto&, bool) {}, Clock::now()); } @@ -586,7 +581,7 @@ TEST_P(AckHandlersTest, AckPacketNumDoesNotExist) { GetParam(), ackFrame, [](const auto&, const auto&, const auto&) {}, - [](auto&, auto&, bool, PacketNum) {}, + [](auto&, auto&, bool) {}, Clock::now()); EXPECT_EQ(1, conn.outstandings.packets.size()); } @@ -705,10 +700,8 @@ TEST_P(AckHandlersTest, NoSkipAckVisitor) { GetParam(), ackFrame, countingAckVisitor, - [&](auto& /*conn*/, - auto& /* packet */, - bool /* processed */, - PacketNum) { /* no-op lossVisitor */ }, + [&](auto& /*conn*/, auto& /* packet */, bool /* processed */ + ) { /* no-op lossVisitor */ }, Clock::now()); EXPECT_EQ(1, ackVisitorCounter); } @@ -755,10 +748,8 @@ TEST_P(AckHandlersTest, SkipAckVisitor) { GetParam(), ackFrame, countingAckVisitor, - [&](auto& /*conn*/, - auto& /* packet */, - bool /* processed */, - PacketNum) { /* no-op lossVisitor */ }, + [&](auto& /*conn*/, auto& /* packet */, bool /* processed */ + ) { /* no-op lossVisitor */ }, Clock::now()); EXPECT_EQ(0, ackVisitorCounter); } @@ -809,10 +800,8 @@ TEST_P(AckHandlersTest, NoDoubleProcess) { GetParam(), ackFrame1, countingAckVisitor, - [&](auto& /*conn*/, - auto& /* packet */, - bool /* processed */, - PacketNum) { /* no-op lossVisitor */ }, + [&](auto& /*conn*/, auto& /* packet */, bool /* processed */ + ) { /* no-op lossVisitor */ }, Clock::now()); EXPECT_EQ(1, ackVisitorCounter); @@ -825,10 +814,8 @@ TEST_P(AckHandlersTest, NoDoubleProcess) { GetParam(), ackFrame2, countingAckVisitor, - [&](auto& /* conn */, - auto& /* packet */, - bool /* processed */, - PacketNum) { /* no-op */ }, + [&](auto& /* conn */, auto& /* packet */, bool /* processed */ + ) { /* no-op */ }, Clock::now()); EXPECT_EQ(1, ackVisitorCounter); } @@ -874,10 +861,8 @@ TEST_P(AckHandlersTest, ClonedPacketsCounter) { GetParam(), ackFrame, countingAckVisitor, - [&](auto& /* conn */, - auto& /* packet */, - bool /* processed */, - PacketNum) { /* no-op */ }, + [&](auto& /* conn */, auto& /* packet */, bool /* processed */ + ) { /* no-op */ }, Clock::now()); EXPECT_EQ(2, ackVisitorCounter); EXPECT_EQ(0, conn.outstandings.clonedPacketsCount); @@ -906,7 +891,7 @@ TEST_P(AckHandlersTest, UpdateMaxAckDelay) { GetParam(), ackFrame, [&](const auto&, const auto&, const auto&) { /* ackVisitor */ }, - [&](auto&, auto&, bool, PacketNum) { /* lossVisitor */ }, + [&](auto&, auto&, bool) { /* lossVisitor */ }, receiveTime); EXPECT_EQ(10us, conn.lossState.mrtt); } @@ -971,10 +956,8 @@ TEST_P(AckHandlersTest, AckNotOutstandingButLoss) { PacketNumberSpace::AppData, ackFrame, countingAckVisitor, - [&](auto& /*conn*/, - auto& /* packet */, - bool /* processed */, - PacketNum) { /* no-op lossVisitor */ }, + [&](auto& /*conn*/, auto& /* packet */, bool /* processed */ + ) { /* no-op lossVisitor */ }, Clock::now()); EXPECT_EQ(0, ackVisitorCounter); } @@ -1006,7 +989,7 @@ TEST_P(AckHandlersTest, UpdatePendingAckStates) { GetParam(), ackFrame, [&](auto, auto, auto) { /* ackVisitor */ }, - [&](auto&, auto&, auto, auto) { /* lossVisitor */ }, + [&](auto&, auto&, auto) { /* lossVisitor */ }, receiveTime); EXPECT_EQ(2468 + 111, conn.lossState.totalBytesSentAtLastAck); EXPECT_EQ(1357 + 111, conn.lossState.totalBytesAckedAtLastAck); @@ -1065,7 +1048,7 @@ TEST_P(AckHandlersTest, AckEventCreation) { GetParam(), ackFrame, [](const auto&, const auto&, const auto&) {}, - [](auto&, auto&, bool, PacketNum) {}, + [](auto&, auto&, bool) {}, ackTime); }