don't reduce the congestion window when a path MTU probe packet is lost

internal/ackhandler/interfaces.go

@@ -16,6 +16,8 @@ type Packet struct {
 	EncryptionLevel protocol.EncryptionLevel
 	SendTime        time.Time
 
+	IsPathMTUProbePacket bool // We don't report the loss of Path MTU probe packets to the congestion controller.
+
 	includedInBytesInFlight bool
 	declaredLost            bool
 	skippedPacket           bool

internal/ackhandler/sent_packet_handler.go

@@ -557,11 +557,13 @@ func (h *sentPacketHandler) detectLostPackets(now time.Time, encLevel protocol.E
 			pnSpace.lossTime = lossTime
 		}
 		if packetLost {
-			h.congestion.OnPacketLost(p.PacketNumber, p.Length, priorInFlight)
 			p.declaredLost = true
-			h.queueFramesForRetransmission(p)
+			// the bytes in flight need to be reduced no matter if the frames in this packet will be retransmitted
-			// the bytes in flight need to be reduced no matter if this packet will be retransmitted
 			h.removeFromBytesInFlight(p)
+			h.queueFramesForRetransmission(p)
+			if !p.IsPathMTUProbePacket {
+				h.congestion.OnPacketLost(p.PacketNumber, p.Length, priorInFlight)
+			}
 		}
 		return true, nil
 	})

internal/ackhandler/sent_packet_handler_test.go

@@ -482,6 +482,27 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed())
 		})
 
+		It("doesn't call OnPacketLost when a Path MTU probe packet is lost", func() {
+			cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(2)
+			var mtuPacketDeclaredLost bool
+			handler.SentPacket(ackElicitingPacket(&Packet{
+				PacketNumber:         1,
+				SendTime:             time.Now().Add(-time.Hour),
+				IsPathMTUProbePacket: true,
+				Frames:               []Frame{{Frame: &wire.PingFrame{}, OnLost: func(wire.Frame) { mtuPacketDeclaredLost = true }}},
+			}))
+			handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2}))
+			// lose packet 1, but don't EXPECT any calls to OnPacketLost()
+			gomock.InOrder(
+				cong.EXPECT().MaybeExitSlowStart(),
+				cong.EXPECT().OnPacketAcked(protocol.PacketNumber(2), protocol.ByteCount(1), protocol.ByteCount(2), gomock.Any()),
+			)
+			ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}}
+			Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed())
+			Expect(mtuPacketDeclaredLost).To(BeTrue())
+			Expect(handler.bytesInFlight).To(BeZero())
+		})
+
 		It("calls OnPacketAcked and OnPacketLost with the right bytes_in_flight value", func() {
 			cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(4)
 			handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-time.Hour)}))

packet_packer.go

@@ -50,6 +50,8 @@ type packetContents struct {
 	frames []ackhandler.Frame
 
 	length protocol.ByteCount
+
+	isMTUProbePacket bool
 }
 
 type coalescedPacket struct {
@@ -98,12 +100,13 @@ func (p *packetContents) ToAckHandlerPacket(now time.Time, q *retransmissionQueu
 		}
 	}
 	return &ackhandler.Packet{
-		PacketNumber:    p.header.PacketNumber,
+		PacketNumber:         p.header.PacketNumber,
-		LargestAcked:    largestAcked,
+		LargestAcked:         largestAcked,
-		Frames:          p.frames,
+		Frames:               p.frames,
-		Length:          p.length,
+		Length:               p.length,
-		EncryptionLevel: encLevel,
+		EncryptionLevel:      encLevel,
-		SendTime:        now,
+		SendTime:             now,
+		IsPathMTUProbePacket: p.isMTUProbePacket,
 	}
 }
 
@@ -701,6 +704,7 @@ func (p *packetPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.B
 	if err != nil {
 		return nil, err
 	}
+	contents.isMTUProbePacket = true
 	return &packedPacket{
 		buffer:         buffer,
 		packetContents: contents,

packet_packer_test.go

@@ -1480,6 +1480,7 @@ var _ = Describe("Packet packer", func() {
 				Expect(p.header.PacketNumber).To(Equal(protocol.PacketNumber(0x43)))
 				Expect(p.EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
 				Expect(p.buffer.Data).To(HaveLen(int(probePacketSize)))
+				Expect(p.packetContents.isMTUProbePacket).To(BeTrue())
 			})
 		})
 	})
@@ -1510,6 +1511,14 @@ var _ = Describe("Converting to AckHandler packets", func() {
 		Expect(p.LargestAcked).To(Equal(protocol.InvalidPacketNumber))
 	})
 
+	It("marks MTU probe packets", func() {
+		packet := &packetContents{
+			header:           &wire.ExtendedHeader{Header: wire.Header{}},
+			isMTUProbePacket: true,
+		}
+		Expect(packet.ToAckHandlerPacket(time.Now(), nil).IsPathMTUProbePacket).To(BeTrue())
+	})
+
 	DescribeTable(
 		"doesn't overwrite the OnLost callback, if it is set",
 		func(hdr wire.Header) {