add Frame.MaxLength and implement it for currently needed frames

frames/ack_frame.go

@@ -65,6 +65,16 @@ func (f *AckFrame) Write(b *bytes.Buffer) error {
 	return nil
 }
 
+// MaxLength of a written frame
+func (f *AckFrame) MaxLength() int {
+	l := 1 + 1 + 6 + 2 + 1 + 1 + 4
+	l += (1 + 2) * 0 /* TODO: num_timestamps */
+	if f.HasNACK() {
+		l += 1 + (6+1)*len(f.NackRanges)
+	}
+	return l
+}
+
 // HasNACK returns if the frame has NACK ranges
 func (f *AckFrame) HasNACK() bool {
 	if len(f.NackRanges) > 0 {
@@ -180,7 +190,7 @@ func ParseAckFrame(r *bytes.Reader) (*AckFrame, error) {
 				nackRange.FirstPacketNumber = frame.LargestObserved - protocol.PacketNumber(missingPacketSequenceNumberDelta+uint64(rangeLength))
 			} else {
 				if missingPacketSequenceNumberDelta == 0 {
-					return nil, errors.New("ACK frame: Continues NACK ranges not yet implemented.")
+					return nil, errors.New("ACK frame: Continues NACK ranges not yet implemented")
 				}
 				lastNackRange := frame.NackRanges[len(frame.NackRanges)-1]
 				nackRange.FirstPacketNumber = lastNackRange.FirstPacketNumber - protocol.PacketNumber(missingPacketSequenceNumberDelta+uint64(rangeLength)) - 1

frames/ack_frame_test.go

@@ -163,6 +163,33 @@ var _ = Describe("AckFrame", func() {
 			Expect(packetNumber1).To(BeEquivalentTo([]byte{1, 0, 0, 0, 0, 0}))
 			Expect(packetNumber2).To(BeEquivalentTo([]byte{1, 0, 0, 0, 0, 0}))
 		})
+
+		It("has proper max length", func() {
+			b := &bytes.Buffer{}
+			f := &AckFrame{
+				Entropy:         2,
+				LargestObserved: 1,
+			}
+			f.Write(b)
+			Expect(f.MaxLength()).To(Equal(b.Len()))
+		})
+
+		It("has proper max length with nack ranges", func() {
+			b := &bytes.Buffer{}
+			f := &AckFrame{
+				Entropy:         2,
+				LargestObserved: 4,
+				NackRanges: []NackRange{
+					NackRange{
+						FirstPacketNumber: 2,
+						Length:            1,
+					},
+				},
+			}
+			err := f.Write(b)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(f.MaxLength()).To(Equal(b.Len()))
+		})
 	})
 
 	Context("self-consistency checks", func() {

frames/connection_close_frame.go

@@ -46,6 +46,11 @@ func ParseConnectionCloseFrame(r *bytes.Reader) (*ConnectionCloseFrame, error) {
 	return frame, nil
 }
 
+// MaxLength of a written frame
+func (f *ConnectionCloseFrame) MaxLength() int {
+	return 1 + 4 + 2 + len(f.ReasonPhrase)
+}
+
 // Write writes an CONNECTION_CLOSE frame.
 func (f *ConnectionCloseFrame) Write(b *bytes.Buffer) error {
 	b.WriteByte(0x02)

frames/connection_close_frame_test.go

@@ -70,6 +70,16 @@ var _ = Describe("ConnectionCloseFrame", func() {
 			err := frame.Write(b)
 			Expect(err).To(HaveOccurred())
 		})
+
+		It("has proper max length", func() {
+			b := &bytes.Buffer{}
+			f := &ConnectionCloseFrame{
+				ErrorCode:    0xDEADBEEF,
+				ReasonPhrase: "foobar",
+			}
+			f.Write(b)
+			Expect(f.MaxLength()).To(Equal(b.Len()))
+		})
 	})
 
 	It("is self-consistent", func() {

frames/frame.go

@@ -5,4 +5,5 @@ import "bytes"
 // A Frame in QUIC
 type Frame interface {
 	Write(b *bytes.Buffer) error
+	MaxLength() int
 }

frames/stream_frame.go

@@ -88,3 +88,8 @@ func (f *StreamFrame) Write(b *bytes.Buffer) error {
 	b.Write(f.Data)
 	return nil
 }
+
+// MaxLength of a written frame
+func (f *StreamFrame) MaxLength() int {
+	return 1 + 4 + 8 + 2 + 1
+}

frames/stream_frame_test.go

@@ -51,6 +51,17 @@ var _ = Describe("StreamFrame", func() {
 				}).Write(b)
 				Expect(b.Bytes()).To(Equal([]byte{0xbf, 0x1, 0, 0, 0, 0x10, 0, 0, 0, 0, 0, 0, 0, 0x06, 0x00, 'f', 'o', 'o', 'b', 'a', 'r'}))
 			})
+
+			It("has proper max length", func() {
+				b := &bytes.Buffer{}
+				f := &StreamFrame{
+					StreamID: 1,
+					Data:     []byte("f"),
+					Offset:   1,
+				}
+				f.Write(b)
+				Expect(f.MaxLength()).To(Equal(b.Len()))
+			})
 		})
 	})
 })