Remove non-retransmittable logic from packer, this is now in ackhandler

packet_packer.go

@@ -118,17 +118,8 @@ func (p *packetPacker) packPacket(leastUnacked protocol.PacketNumber, handshakeP
 		if p.stopWaiting == nil {
 			return nil, errors.New("PacketPacker BUG: Handshake retransmissions must contain a StopWaitingFrame")
 		}
-		payloadFrames = append(payloadFrames, p.stopWaiting)
+		payloadFrames = []frames.Frame{p.stopWaiting}
-		// don't retransmit Acks and StopWaitings
+		payloadFrames = append(payloadFrames, handshakePacketToRetransmit.Frames...)
-		for _, f := range handshakePacketToRetransmit.Frames {
-			switch f.(type) {
-			case *frames.AckFrame:
-				continue
-			case *frames.StopWaitingFrame:
-				continue
-			}
-			payloadFrames = append(payloadFrames, f)
-		}
 	} else if isCryptoStreamFrame {
 		maxLen := protocol.MaxFrameAndPublicHeaderSize - protocol.NonForwardSecurePacketSizeReduction - publicHeaderLength
 		payloadFrames = []frames.Frame{p.streamFramer.PopCryptoStreamFrame(maxLen)}

packet_packer_test.go

@@ -671,36 +671,6 @@ var _ = Describe("Packet packer", func() {
 			Expect(p.encryptionLevel).To(Equal(protocol.EncryptionSecure))
 		})
 
-		It("removes non-retransmittable frames", func() {
-			wuf := &frames.WindowUpdateFrame{StreamID: 5, ByteOffset: 10}
-			packet := &ackhandler.Packet{
-				EncryptionLevel: protocol.EncryptionSecure,
-				Frames: []frames.Frame{
-					sf,
-					&frames.StopWaitingFrame{},
-					wuf,
-					&frames.AckFrame{},
-				},
-			}
-			p, err := packer.RetransmitNonForwardSecurePacket(packet)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(p.frames).To(HaveLen(3))
-			Expect(p.frames).To(ContainElement(sf))
-			Expect(p.frames).To(ContainElement(swf))
-			Expect(p.frames).To(ContainElement(wuf))
-			Expect(p.encryptionLevel).To(Equal(protocol.EncryptionSecure))
-		})
-
-		It("doesn't pack a packet for a non-retransmittable packet", func() {
-			packet := &ackhandler.Packet{
-				EncryptionLevel: protocol.EncryptionSecure,
-				Frames:          []frames.Frame{&frames.AckFrame{}, &frames.StopWaitingFrame{}},
-			}
-			p, err := packer.RetransmitNonForwardSecurePacket(packet)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(p).To(BeNil())
-		})
-
 		// this should never happen, since non forward-secure packets are limited to a size smaller than MaxPacketSize, such that it is always possible to retransmit them without splitting the StreamFrame
 		// (note that the retransmitted packet needs to have enough space for the StopWaitingFrame)
 		It("refuses to send a packet larger than MaxPacketSize", func() {

session_test.go

@@ -974,19 +974,6 @@ var _ = Describe("Session", func() {
 				Expect(swf.LeastUnacked).To(Equal(protocol.PacketNumber(0x1337)))
 			})
 
-			It("doesn't retransmit non-retransmittable packets", func() {
-				sph.retransmissionQueue = []*ackhandler.Packet{{
-					Frames: []frames.Frame{
-						&frames.AckFrame{},
-						&frames.StopWaitingFrame{},
-					},
-					EncryptionLevel: protocol.EncryptionUnencrypted,
-				}}
-				err := sess.sendPacket()
-				Expect(err).ToNot(HaveOccurred())
-				Expect(mconn.written).To(BeEmpty())
-			})
-
 			It("retransmit a packet encrypted with the initial encryption", func() {
 				sf := &frames.StreamFrame{StreamID: 1, Data: []byte("foobar")}
 				sph.retransmissionQueue = []*ackhandler.Packet{{