From d20c1bfaed460659c1fd66466526171d205cbe38 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Fri, 21 Feb 2020 10:05:17 +0700 Subject: [PATCH] remove unused parameter from SentPacketHandler.ReceivedAck --- internal/ackhandler/interfaces.go | 2 +- internal/ackhandler/sent_packet_handler.go | 12 +-- .../ackhandler/sent_packet_handler_test.go | 96 ++++++++----------- .../mocks/ackhandler/sent_packet_handler.go | 8 +- session.go | 10 +- session_test.go | 32 +++---- 6 files changed, 73 insertions(+), 87 deletions(-) diff --git a/internal/ackhandler/interfaces.go b/internal/ackhandler/interfaces.go index c57099bce..4b3022399 100644 --- a/internal/ackhandler/interfaces.go +++ b/internal/ackhandler/interfaces.go @@ -24,7 +24,7 @@ type Packet struct { type SentPacketHandler interface { // SentPacket may modify the packet SentPacket(packet *Packet) - ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, encLevel protocol.EncryptionLevel, recvTime time.Time) error + ReceivedAck(ackFrame *wire.AckFrame, encLevel protocol.EncryptionLevel, recvTime time.Time) error DropPackets(protocol.EncryptionLevel) ResetForRetry() error SetHandshakeComplete() diff --git a/internal/ackhandler/sent_packet_handler.go b/internal/ackhandler/sent_packet_handler.go index 54950b0fe..631d77ac7 100644 --- a/internal/ackhandler/sent_packet_handler.go +++ b/internal/ackhandler/sent_packet_handler.go @@ -187,26 +187,26 @@ func (h *sentPacketHandler) sentPacketImpl(packet *Packet) bool /* is ack-elicit return isAckEliciting } -func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, encLevel protocol.EncryptionLevel, rcvTime time.Time) error { +func (h *sentPacketHandler) ReceivedAck(ack *wire.AckFrame, encLevel protocol.EncryptionLevel, rcvTime time.Time) error { pnSpace := h.getPacketNumberSpace(encLevel) - largestAcked := ackFrame.LargestAcked() + largestAcked := ack.LargestAcked() if largestAcked > pnSpace.largestSent { return qerr.Error(qerr.ProtocolViolation, "Received ACK for an unsent packet") } pnSpace.largestAcked = utils.MaxPacketNumber(pnSpace.largestAcked, largestAcked) - if !pnSpace.pns.Validate(ackFrame) { + if !pnSpace.pns.Validate(ack) { return qerr.Error(qerr.ProtocolViolation, "Received an ACK for a skipped packet number") } // maybe update the RTT - if p := pnSpace.history.GetPacket(ackFrame.LargestAcked()); p != nil { + if p := pnSpace.history.GetPacket(ack.LargestAcked()); p != nil { // don't use the ack delay for Initial and Handshake packets var ackDelay time.Duration if encLevel == protocol.Encryption1RTT { - ackDelay = utils.MinDuration(ackFrame.DelayTime, h.rttStats.MaxAckDelay()) + ackDelay = utils.MinDuration(ack.DelayTime, h.rttStats.MaxAckDelay()) } h.rttStats.UpdateRTT(rcvTime.Sub(p.SendTime), ackDelay, rcvTime) if h.logger.Debug() { @@ -225,7 +225,7 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumbe } } - ackedPackets, err := h.determineNewlyAckedPackets(ackFrame, encLevel) + ackedPackets, err := h.determineNewlyAckedPackets(ack, encLevel) if err != nil { return err } diff --git a/internal/ackhandler/sent_packet_handler_test.go b/internal/ackhandler/sent_packet_handler_test.go index 4c07cebb4..f8114b39c 100644 --- a/internal/ackhandler/sent_packet_handler_test.go +++ b/internal/ackhandler/sent_packet_handler_test.go @@ -141,34 +141,32 @@ var _ = Describe("SentPacketHandler", func() { Context("ACK validation", func() { It("accepts ACKs sent in packet 0", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}} - err := handler.ReceivedAck(ack, 0, protocol.Encryption1RTT, time.Now()) - Expect(err).ToNot(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(5))) }) It("accepts multiple ACKs sent in the same packet", func() { ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 3}}} ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 4}}} - Expect(handler.ReceivedAck(ack1, 1337, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(3))) // this wouldn't happen in practice // for testing purposes, we pretend send a different ACK frame in a duplicated packet, to be able to verify that it actually doesn't get processed - Expect(handler.ReceivedAck(ack2, 1337, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(4))) }) It("rejects ACKs with a too high LargestAcked packet number", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 9999}}} - err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) - Expect(err).To(MatchError("PROTOCOL_VIOLATION: Received ACK for an unsent packet")) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(MatchError("PROTOCOL_VIOLATION: Received ACK for an unsent packet")) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10))) }) It("ignores repeated ACKs", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 3}}} - Expect(handler.ReceivedAck(ack, 1337, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6))) - Expect(handler.ReceivedAck(ack, 1337+1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(3))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6))) }) @@ -194,7 +192,7 @@ var _ = Describe("SentPacketHandler", func() { It("adjusts the LargestAcked, and adjusts the bytes in flight", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(5))) expectInPacketHistoryOrLost([]protocol.PacketNumber{6, 7, 8, 9}, protocol.Encryption1RTT) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4))) @@ -202,7 +200,7 @@ var _ = Describe("SentPacketHandler", func() { It("acks packet 0", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 0}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(getPacket(0, protocol.Encryption1RTT)).To(BeNil()) expectInPacketHistoryOrLost([]protocol.PacketNumber{1, 2, 3, 4, 5, 6, 7, 8, 9}, protocol.Encryption1RTT) }) @@ -219,7 +217,7 @@ var _ = Describe("SentPacketHandler", func() { }}, })) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(acked).To(BeTrue()) }) @@ -230,13 +228,13 @@ var _ = Describe("SentPacketHandler", func() { {Smallest: 1, Largest: 3}, }, } - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 4, 5}, protocol.Encryption1RTT) }) It("does not ack packets below the LowestAcked", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 3, Largest: 8}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 1, 2, 9}, protocol.Encryption1RTT) }) @@ -249,7 +247,7 @@ var _ = Describe("SentPacketHandler", func() { {Smallest: 1, Largest: 1}, }, } - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 2, 4, 5, 8}, protocol.Encryption1RTT) }) @@ -260,16 +258,16 @@ var _ = Describe("SentPacketHandler", func() { {Smallest: 1, Largest: 4}, }, } - Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 5, 7, 8, 9}, protocol.Encryption1RTT) ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} // now ack 5 - Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 7, 8, 9}, protocol.Encryption1RTT) }) It("processes an ACK that contains old ACK ranges", func() { ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} - Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 7, 8, 9}, protocol.Encryption1RTT) ack2 := &wire.AckFrame{ AckRanges: []wire.AckRange{ @@ -278,7 +276,7 @@ var _ = Describe("SentPacketHandler", func() { {Smallest: 1, Largest: 1}, }, } - Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 7, 9}, protocol.Encryption1RTT) }) }) @@ -292,16 +290,13 @@ var _ = Describe("SentPacketHandler", func() { getPacket(6, protocol.Encryption1RTT).SendTime = now.Add(-1 * time.Minute) // Now, check that the proper times are used when calculating the deltas ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}} - err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) - Expect(err).NotTo(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second)) ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 2}}} - err = handler.ReceivedAck(ack, 2, protocol.Encryption1RTT, time.Now()) - Expect(err).NotTo(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second)) ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} - err = handler.ReceivedAck(ack, 3, protocol.Encryption1RTT, time.Now()) - Expect(err).NotTo(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 1*time.Minute, 1*time.Second)) }) @@ -315,7 +310,7 @@ var _ = Describe("SentPacketHandler", func() { AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}, DelayTime: 5 * time.Minute, } - Expect(handler.ReceivedAck(ack, 1, protocol.EncryptionInitial, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.EncryptionInitial, time.Now())).To(Succeed()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second)) }) @@ -328,7 +323,7 @@ var _ = Describe("SentPacketHandler", func() { AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}, DelayTime: 5 * time.Minute, } - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second)) }) @@ -341,7 +336,7 @@ var _ = Describe("SentPacketHandler", func() { AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}, DelayTime: 5 * time.Minute, } - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 9*time.Minute, 1*time.Second)) }) }) @@ -377,25 +372,25 @@ var _ = Describe("SentPacketHandler", func() { It("determines which ACK we have received an ACK for", func() { ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 15}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) }) It("doesn't do anything when the acked packet didn't contain an ACK", func() { ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 15, Largest: 15}}} - Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101))) - Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101))) }) It("doesn't decrease the value", func() { ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 14, Largest: 14}}} ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} - Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) - Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) }) }) @@ -439,8 +434,7 @@ var _ = Describe("SentPacketHandler", func() { handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2})) handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 3})) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 2}}} - err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, rcvTime) - Expect(err).NotTo(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, rcvTime)).To(Succeed()) }) It("doesn't call OnPacketAcked when a retransmitted packet is acked", func() { @@ -455,12 +449,10 @@ var _ = Describe("SentPacketHandler", func() { cong.EXPECT().OnPacketLost(protocol.PacketNumber(1), protocol.ByteCount(1), protocol.ByteCount(2)), ) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} - err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) - Expect(err).ToNot(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) // don't EXPECT any further calls to the congestion controller ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 2}}} - err = handler.ReceivedAck(ack, 2, protocol.Encryption1RTT, time.Now()) - Expect(err).ToNot(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) }) It("calls OnPacketAcked and OnPacketLost with the right bytes_in_flight value", func() { @@ -477,8 +469,7 @@ var _ = Describe("SentPacketHandler", func() { cong.EXPECT().OnPacketLost(protocol.PacketNumber(1), protocol.ByteCount(1), protocol.ByteCount(4)), ) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} - err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now().Add(-30*time.Minute)) - Expect(err).ToNot(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now().Add(-30*time.Minute))).To(Succeed()) // receive the second ACK gomock.InOrder( cong.EXPECT().MaybeExitSlowStart(), @@ -486,8 +477,7 @@ var _ = Describe("SentPacketHandler", func() { cong.EXPECT().OnPacketLost(protocol.PacketNumber(3), protocol.ByteCount(1), protocol.ByteCount(2)), ) ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 4, Largest: 4}}} - err = handler.ReceivedAck(ack, 2, protocol.Encryption1RTT, time.Now()) - Expect(err).ToNot(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) }) It("passes the bytes in flight to CanSend", func() { @@ -559,8 +549,7 @@ var _ = Describe("SentPacketHandler", func() { handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 10})) handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 11})) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 10, Largest: 11}}} - err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) - Expect(err).ToNot(HaveOccurred()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.GetLossDetectionTimeout()).To(BeZero()) }) @@ -714,17 +703,15 @@ var _ = Describe("SentPacketHandler", func() { Expect(handler.OnLossDetectionTimeout()).To(Succeed()) Expect(handler.SendMode()).To(Equal(SendPTOAppData)) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) Expect(handler.SendMode()).To(Equal(SendAny)) }) It("handles ACKs for the original packet", func() { handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 5, SendTime: time.Now().Add(-time.Hour)})) handler.rttStats.UpdateRTT(time.Second, 0, time.Now()) - err := handler.OnLossDetectionTimeout() - Expect(err).ToNot(HaveOccurred()) - err = handler.OnLossDetectionTimeout() - Expect(err).ToNot(HaveOccurred()) + Expect(handler.OnLossDetectionTimeout()).To(Succeed()) + Expect(handler.OnLossDetectionTimeout()).To(Succeed()) }) }) @@ -734,7 +721,7 @@ var _ = Describe("SentPacketHandler", func() { handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: i})) } ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 6, Largest: 6}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) expectInPacketHistory([]protocol.PacketNumber{4, 5}, protocol.Encryption1RTT) Expect(lostPackets).To(Equal([]protocol.PacketNumber{1, 2, 3})) }) @@ -748,7 +735,7 @@ var _ = Describe("SentPacketHandler", func() { Expect(handler.appDataPackets.lossTime.IsZero()).To(BeTrue()) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, now)).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, now)).To(Succeed()) // no need to set an alarm, since packet 1 was already declared lost Expect(handler.appDataPackets.lossTime.IsZero()).To(BeTrue()) Expect(handler.bytesInFlight).To(BeZero()) @@ -763,7 +750,7 @@ var _ = Describe("SentPacketHandler", func() { Expect(handler.appDataPackets.lossTime.IsZero()).To(BeTrue()) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} - Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, now.Add(-time.Second))).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, now.Add(-time.Second))).To(Succeed()) Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Second)) // Packet 1 should be considered lost (1+1/8) RTTs after it was sent. @@ -778,7 +765,7 @@ var _ = Describe("SentPacketHandler", func() { Expect(handler.initialPackets.lossTime.IsZero()).To(BeTrue()) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} - Expect(handler.ReceivedAck(ack, 1, protocol.EncryptionInitial, now.Add(-time.Second))).To(Succeed()) + Expect(handler.ReceivedAck(ack, protocol.EncryptionInitial, now.Add(-time.Second))).To(Succeed()) Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Second)) // Packet 1 should be considered lost (1+1/8) RTTs after it was sent. @@ -793,8 +780,7 @@ var _ = Describe("SentPacketHandler", func() { EncryptionLevel: protocol.Encryption1RTT, })) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} - err := handler.ReceivedAck(ack, 1, protocol.EncryptionHandshake, time.Now()) - Expect(err).To(MatchError("PROTOCOL_VIOLATION: Received ACK for an unsent packet")) + Expect(handler.ReceivedAck(ack, protocol.EncryptionHandshake, time.Now())).To(MatchError("PROTOCOL_VIOLATION: Received ACK for an unsent packet")) }) It("deletes Initial packets", func() { diff --git a/internal/mocks/ackhandler/sent_packet_handler.go b/internal/mocks/ackhandler/sent_packet_handler.go index abde89aaf..0f56d2302 100644 --- a/internal/mocks/ackhandler/sent_packet_handler.go +++ b/internal/mocks/ackhandler/sent_packet_handler.go @@ -150,17 +150,17 @@ func (mr *MockSentPacketHandlerMockRecorder) QueueProbePacket(arg0 interface{}) } // ReceivedAck mocks base method -func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.PacketNumber, arg2 protocol.EncryptionLevel, arg3 time.Time) error { +func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.EncryptionLevel, arg2 time.Time) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReceivedAck", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "ReceivedAck", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // ReceivedAck indicates an expected call of ReceivedAck -func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2) } // ResetForRetry mocks base method diff --git a/session.go b/session.go index 5587ba7ce..6abceac6d 100644 --- a/session.go +++ b/session.go @@ -851,7 +851,7 @@ func (s *session) handleUnpackedPacket(packet *unpackedPacket, rcvTime time.Time if s.traceCallback != nil || s.qlogger != nil { frames = append(frames, frame) } - if err := s.handleFrame(frame, packet.packetNumber, packet.encryptionLevel); err != nil { + if err := s.handleFrame(frame, packet.encryptionLevel); err != nil { return err } } @@ -875,7 +875,7 @@ func (s *session) handleUnpackedPacket(packet *unpackedPacket, rcvTime time.Time return s.receivedPacketHandler.ReceivedPacket(packet.packetNumber, packet.encryptionLevel, rcvTime, isAckEliciting) } -func (s *session) handleFrame(f wire.Frame, pn protocol.PacketNumber, encLevel protocol.EncryptionLevel) error { +func (s *session) handleFrame(f wire.Frame, encLevel protocol.EncryptionLevel) error { var err error wire.LogFrame(s.logger, f, false) switch frame := f.(type) { @@ -884,7 +884,7 @@ func (s *session) handleFrame(f wire.Frame, pn protocol.PacketNumber, encLevel p case *wire.StreamFrame: err = s.handleStreamFrame(frame) case *wire.AckFrame: - err = s.handleAckFrame(frame, pn, encLevel) + err = s.handleAckFrame(frame, encLevel) case *wire.ConnectionCloseFrame: s.handleConnectionCloseFrame(frame) case *wire.ResetStreamFrame: @@ -1040,8 +1040,8 @@ func (s *session) handleHandshakeDoneFrame() error { return nil } -func (s *session) handleAckFrame(frame *wire.AckFrame, pn protocol.PacketNumber, encLevel protocol.EncryptionLevel) error { - if err := s.sentPacketHandler.ReceivedAck(frame, pn, encLevel, s.lastPacketReceivedTime); err != nil { +func (s *session) handleAckFrame(frame *wire.AckFrame, encLevel protocol.EncryptionLevel) error { + if err := s.sentPacketHandler.ReceivedAck(frame, encLevel, s.lastPacketReceivedTime); err != nil { return err } if encLevel == protocol.Encryption1RTT { diff --git a/session_test.go b/session_test.go index 5495056af..d6ca84dd3 100644 --- a/session_test.go +++ b/session_test.go @@ -149,9 +149,9 @@ var _ = Describe("Session", func() { It("informs the SentPacketHandler about ACKs", func() { f := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 3}}} sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sph.EXPECT().ReceivedAck(f, protocol.PacketNumber(42), protocol.EncryptionHandshake, gomock.Any()) + sph.EXPECT().ReceivedAck(f, protocol.EncryptionHandshake, gomock.Any()) sess.sentPacketHandler = sph - err := sess.handleAckFrame(f, 42, protocol.EncryptionHandshake) + err := sess.handleAckFrame(f, protocol.EncryptionHandshake) Expect(err).ToNot(HaveOccurred()) }) @@ -159,13 +159,13 @@ var _ = Describe("Session", func() { cryptoSetup.EXPECT().SetLargest1RTTAcked(protocol.PacketNumber(3)) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 3}}} sph := mockackhandler.NewMockSentPacketHandler(mockCtrl) - sph.EXPECT().ReceivedAck(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) + sph.EXPECT().ReceivedAck(gomock.Any(), gomock.Any(), gomock.Any()) sph.EXPECT().GetLowestPacketNotConfirmedAcked().Return(protocol.PacketNumber(0x42)) sess.sentPacketHandler = sph rph := mockackhandler.NewMockReceivedPacketHandler(mockCtrl) rph.EXPECT().IgnoreBelow(protocol.PacketNumber(0x42)) sess.receivedPacketHandler = rph - Expect(sess.handleAckFrame(ack, 0, protocol.Encryption1RTT)).To(Succeed()) + Expect(sess.handleAckFrame(ack, protocol.Encryption1RTT)).To(Succeed()) }) }) @@ -201,7 +201,7 @@ var _ = Describe("Session", func() { Expect(sess.handleFrame(&wire.ResetStreamFrame{ StreamID: 3, ErrorCode: 42, - }, 0, protocol.EncryptionUnspecified)).To(Succeed()) + }, protocol.EncryptionUnspecified)).To(Succeed()) }) }) @@ -236,7 +236,7 @@ var _ = Describe("Session", func() { Expect(sess.handleFrame(&wire.MaxStreamDataFrame{ StreamID: 10, ByteOffset: 1337, - }, 0, protocol.EncryptionUnspecified)).To(Succeed()) + }, protocol.EncryptionUnspecified)).To(Succeed()) }) }) @@ -278,7 +278,7 @@ var _ = Describe("Session", func() { Expect(sess.handleFrame(&wire.StopSendingFrame{ StreamID: 3, ErrorCode: 1337, - }, 0, protocol.EncryptionUnspecified)).To(Succeed()) + }, protocol.EncryptionUnspecified)).To(Succeed()) }) }) @@ -286,23 +286,23 @@ var _ = Describe("Session", func() { Expect(sess.handleFrame(&wire.NewConnectionIDFrame{ SequenceNumber: 10, ConnectionID: protocol.ConnectionID{1, 2, 3, 4}, - }, 1, protocol.Encryption1RTT)).To(Succeed()) + }, protocol.Encryption1RTT)).To(Succeed()) Expect(sess.connIDManager.queue.Back().Value.ConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4})) }) It("handles PING frames", func() { - err := sess.handleFrame(&wire.PingFrame{}, 0, protocol.EncryptionUnspecified) + err := sess.handleFrame(&wire.PingFrame{}, protocol.EncryptionUnspecified) Expect(err).NotTo(HaveOccurred()) }) It("rejects PATH_RESPONSE frames", func() { - err := sess.handleFrame(&wire.PathResponseFrame{Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}}, 0, protocol.EncryptionUnspecified) + err := sess.handleFrame(&wire.PathResponseFrame{Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}}, protocol.EncryptionUnspecified) Expect(err).To(MatchError("unexpected PATH_RESPONSE frame")) }) It("handles PATH_CHALLENGE frames", func() { data := [8]byte{1, 2, 3, 4, 5, 6, 7, 8} - err := sess.handleFrame(&wire.PathChallengeFrame{Data: data}, 0, protocol.EncryptionUnspecified) + err := sess.handleFrame(&wire.PathChallengeFrame{Data: data}, protocol.EncryptionUnspecified) Expect(err).ToNot(HaveOccurred()) frames, _ := sess.framer.AppendControlFrames(nil, 1000) Expect(frames).To(Equal([]ackhandler.Frame{{Frame: &wire.PathResponseFrame{Data: data}}})) @@ -316,17 +316,17 @@ var _ = Describe("Session", func() { }) It("handles BLOCKED frames", func() { - err := sess.handleFrame(&wire.DataBlockedFrame{}, 0, protocol.EncryptionUnspecified) + err := sess.handleFrame(&wire.DataBlockedFrame{}, protocol.EncryptionUnspecified) Expect(err).NotTo(HaveOccurred()) }) It("handles STREAM_BLOCKED frames", func() { - err := sess.handleFrame(&wire.StreamDataBlockedFrame{}, 0, protocol.EncryptionUnspecified) + err := sess.handleFrame(&wire.StreamDataBlockedFrame{}, protocol.EncryptionUnspecified) Expect(err).NotTo(HaveOccurred()) }) It("handles STREAM_ID_BLOCKED frames", func() { - err := sess.handleFrame(&wire.StreamsBlockedFrame{}, 0, protocol.EncryptionUnspecified) + err := sess.handleFrame(&wire.StreamsBlockedFrame{}, protocol.EncryptionUnspecified) Expect(err).NotTo(HaveOccurred()) }) @@ -350,7 +350,7 @@ var _ = Describe("Session", func() { ErrorCode: qerr.StreamLimitError, ReasonPhrase: "foobar", } - Expect(sess.handleFrame(ccf, 0, protocol.EncryptionUnspecified)).To(Succeed()) + Expect(sess.handleFrame(ccf, protocol.EncryptionUnspecified)).To(Succeed()) Eventually(sess.Context().Done()).Should(BeClosed()) }) @@ -375,7 +375,7 @@ var _ = Describe("Session", func() { ReasonPhrase: "foobar", IsApplicationError: true, } - Expect(sess.handleFrame(ccf, 0, protocol.EncryptionUnspecified)).To(Succeed()) + Expect(sess.handleFrame(ccf, protocol.EncryptionUnspecified)).To(Succeed()) Eventually(sess.Context().Done()).Should(BeClosed()) })